Search

8.14 — Anonymous objects

In certain cases, we need a variable only temporarily. For example, consider the following situation:

In the add() function, note that the sum variable is really only used as a temporary placeholder variable. It doesn’t contribute much -- rather, its only function is to transfer the result of the expression to the return value.

There is actually an easier way to write the add() function using an anonymous object. An anonymous object is essentially a value that has no name. Because they have no name, there’s no way to refer to them beyond the point where they are created. Consequently, they have “expression scope”, meaning they are created, evaluated, and destroyed all within a single expression.

Here is the add() function rewritten using an anonymous object:

When the expression x + y is evaluated, the result is placed in an anonymous object. A copy of the anonymous object is then returned to the caller by value, and the anonymous object is destroyed.

This works not only with return values, but also with function parameters. For example, instead of this:

We can write this:

In this case, the expression 5 + 3 is evaluated to produce the result 8, which is placed in an anonymous object. A copy of this anonymous object is then passed to the printValue() function, (which prints the value 8) and then is destroyed.

Note how much cleaner this keeps our code -- we don’t have to litter the code with temporary variables that are only used once.

Anonymous class objects

Although our prior examples have been with built-in data types, it is possible to construct anonymous objects of our own class types as well. This is done by creating objects like normal, but omitting the variable name.

In the above code, Cents(7) will create an anonymous Cents object, initialize it with the value 7, and then destroy it. In this context, that isn’t going to do us much good. So let’s take a look at an example where it can be put to good use:

Note that this example is very similar to the prior one using integers. In this case, our main() function is passing a Cents object (named cents) to function print().

We can simplify this program by using anonymous objects:

As you’d expect, this prints:

6 cents

Now let’s take a look at a slightly more complex example:

In the above example, we’re using quite a few named Cents values. In the add() function, we have a Cents value named sum that we’re using as an intermediary value to hold the sum before we return it. And in function main(), we have another Cents value named sum also used as an intermediary value.

We can make our program simpler by using anonymous values:

This version of add() functions identically to the one above, except it uses an anonymous Cents value instead of a named variable. Also note that in main(), we no longer use a named “sum” variable as temporary storage. Instead, we use the return value of add() anonymously!

As a result, our program is shorter, cleaner, and generally easier to follow (once you understand the concept).

In fact, because cents1 and cents2 are only used in one place, we can anonymize this even further:

Summary

In C++, anonymous objects are primarily used either to pass or return values without having to create lots of temporary variables to do so. Memory allocated dynamically is also done so anonymously (which is why its address must be assigned to a pointer, otherwise we’d have no way to refer to it).

However, it is worth noting that anonymous objects are treated as rvalues (not lvalues, which have an address). This means anonymous objects can only be passed or returned by value or const reference. Otherwise, a named variable must be used instead.

It is also worth noting that because anonymous objects have expression scope, they can only be used once. If you need to reference a value in multiple expressions, you should use a named variable instead.

Note: Some compilers, such as Visual Studio, will let you set non-const references to anonymous objects. This is non-standard behavior.

8.15 -- Nested types in classes
Index
8.13 -- Friend functions and classes

77 comments to 8.14 — Anonymous objects

  • Jeff

    Perhaps worth noting here (and hopefully it's addressed later), that returning a copy of the object created on the stack only "magically works" if the compiler-generated copy constructor replicates the object. At least in my limited C++ experience, that copy constructor is a shallow copy, which will fail to replicate non-trivial object structures.

  • Conor

    I think this is the right section to ask this. Say I have 3 functions called Foo(), Boo() and Goo(). Boo() and Goo() both return char*'s, initially we have Foo(Boo()) where Boo() calls Goo(). My question is, is there a memory leak here as Foo() is void? Or does the memory be freed up again once the function finishes executing?

    • It depends on the creation of the char* in question. It will only leak memory if the char* was dynamically allocated, otherwise you'll return a temporary or don't have a problem.

      • Conor

        Goo() creates an IntPtr object from .NET and ToPointer is called on it which is then casted to a char*. So a char* is passed all the way up so I'm guessing its fine as its not dynamically allocated and IntPtr handles its own de-allocation implicitly.

        • Once the object leaves .NET and is casted there should be no way for the runtime to know when the object is last used. Meaning that it's either leaking, because it's never being freed, or the object is destroyed right away, leaving you with a dangling pointer. You do some reading on this, I have no clue about .NET or integration into C++, this is just what I think happens.
          If what I said is true, copy the data as soon as you get it and handle the memory yourself.

  • i don't understand this " Memory allocated dynamically is also done so anonymously (which is why its address must be assigned to a pointer, otherwise we’d have no way to refer to it)." does this mean that anonymous objects is stored in the heap as a dynamic allocated object ?  or you mean that just it works the same as dynamic allocation as it does not have a reference we can't refer to it

Leave a Comment

Put all code inside code tags: [code]your code here[/code]