Can You Pass a C Object into Its Own Constructor?

Passing C Objects into Their Own Constructors

In C , it may seem counterintuitive but it is indeed legal to pass a C object into its own constructor. Consider the following code snippet:

#include <iostream>

struct Foo {
    Foo(Foo& bar) {
        std::cout << &bar << std::endl;
    }
};

int main(int argc, char** argv) {
    Foo foo(foo); // Surprising, yet valid
    std::cout << &foo << std::endl;
}

In this example, we are passing the address of the constructed Foo object (&foo) into its own constructor. This may resemble a circular definition, but it is not considered undefined behavior by the C standards.

Explanation

The standard allows us to use uninitialized objects in limited ways before their full initialization. Specifically, binding a reference to it or taking its address is permitted. This is defined in defect report 363 and section 3.8 of the draft C 14 standard.

This means that in the code above, we are not violating any constraints set by the language. We are merely using the uninitialized foo object within the constructor in a way that is compliant with the standard.

Clang's Warning

However, it is worth noting that some compilers like Clang may issue a warning about uninitialized variables. This is because producing indeterminate values from uninitialized automatic variables is generally considered undefined behavior. In this case, though, we are not introducing indeterminacy since we are only binding a reference and taking the address within the constructor.

Limitations

It is important to emphasize that while this behavior is permitted by the standard, it should not be considered a good practice or have any practical use cases. The primary intention of this discussion is to shed light on a lesser-known aspect of C language semantics.

The above is the detailed content of Can You Pass a C Object into Its Own Constructor?. For more information, please follow other related articles on the PHP Chinese website!