C和C++中的临时对象

Question

C code

#include <stdio.h>

typedef struct
{
    int a;
}A;

int main()
{
    A(); // this line gives error
    return 0;
}

Output

Error: Expected identifier or '('

C++ code

#include <iostream>

struct A
{
    int a;

    A()
    {
        std::cout<<"Ctor-A\n";
    }

    ~A()
    {
        std::cout<<"Dctor-A\n";
    }
};

int main()
{
    A(); // creates temporary object and destroyed it 
    return 0;
}

Output

Ctor-A
Dctor-A

I know about the "Rule of three", but code becomes complicated and most compilers don't give errors if we don't follow the rule. So I avoided creation of a copy constructor and an overloaded assignment operator.

Why does A()/A{} create a temporary object in C++, but not in C? What's another way to create a temporary object in C?

Answer 1

In C (C99 and later) you can create a structure with automatic lifetime using a Compound Literal .

The syntax is (A){ initializers, for, struct, members } .

The lifetime is automatic, not temporary, so the structure created in this way does not vanish at the end of the full-expression, but at the end of the enclosing scope.

Answer 2

This expression

A()

is considered by C compilers as a function call. In C++ such an expression means a call of a constructor provided that A is a class type.

To create a temporary object in C you could declare a function like for example

struct A { int a; } A( int x )
{
    struct A a = { .a = x };
    return a;
}

and then you can call the function creating a temporary object of the type struct A like

A( 10 );

Here is a demonstrative program.

#include <stdio.h>

struct A { int a; } A( int x )
{
    struct A a = { .a = x };
    return a;
}

int main(void) 
{
    struct A a = A( 10 );
    
    printf( "a.a = %d\n", a.a );
    
    return 0;
}

The program output is

a.a = 10

Answer 3

A() calls the constructor for the struct A in the C++ code. However, C doesn't support constructors / destructors, or even objects (in the sense of OOP) in fact. The only way to create a temporary object as you describe in C would be to declare a variable of type A and wait for it to go out of scope, where the memory allocated for it will be popped from the stack, or to allocate a variable on the heap and free it in the next line.