Search

8.14 — Anonymous variables and 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) -- therefore, all rules about passing and returning rvalues apply.

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.

7.14 -- Error handling strategies
Index
8.13 -- Friend functions and classes

22 comments to 8.14 — Anonymous variables and objects

  • benquan

    Great article, but the last paragraph is wrong and misleading, let's go over it:

    >>> In C++, anonymous variables are primarily used either to pass or return values without having to create lots of temporary variables to do so.
    Actually, anonymous variables are still temporary variables, they just don't need to have a name. There is no memory/CPU benefits here.

    >>> However, it is worth noting that anonymous objects can only be passed or returned by value!
    I'm not quite understand this.

    >>> If a variable is passed or returned by reference or address, a named variable must be used instead.
    Not 100% true. You can pass anonymous variable to a function if it accepts const reference. It is totally legitimate (personal, I think you should do so if possible, see the reason below).
    Your last example can be re-written as:
    Cents Add(const Cents &c1, const Cents &c2)
    {
    return Cents(c1.GetCents() + c2.GetCents());
    }

    std::cout << "I have " << Add(Cents(6), Cent(8).GetCents() << " cents." <>> It is also worth noting that because anonymous variables have expression scope, if you need to reference a value in multiple expressions, you will have to use a named variable.
    But, if you don't need to reference it in multiple expressions, why do you have to give them names? Sometimes you have to give them fake names, which makes no good sense.

    Also, the life of the named variable extends to the end of the current code block, which is unnecessary:
    1. it may poplutes the naming space for the rest of the code;
    2. it occupies the memory longer than needed.
    Some people use extra brackets to limit the scope of temporary variables, personally, I think it makes code ugly. Like this:
    {
    MyClass temp_obj;
    Foo(temp_obj);
    }
    If Foo() accepts const reference, you should just replace it with:
    Foo(MyClass());

    If Foo() do accepts non-const reference, then, it implies that Foo() could modify the parameter, but you do not intent to reference to the modified result, that is a bigger design issue you should resolve first.

  • pravin_ms

    Hi Alex,

    Your explanations are precise and that too in simple language. thanks for posting such an useful site.

    One quick query. What about Static objects ? I have heard that there are something called as Static objects. I couldn't find anywhere in the site. Is that being missed in the post or is there really anything called as Static Objects ?

    Please can you confirm this ?

Leave a Reply

You can use these HTML tags

<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code class="" title="" data-url=""> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong> <pre class="" title="" data-url=""> <span class="" title="" data-url="">