Re: object of type int

ChasW posted:


When working with an intrinsic type such as "int", the two forms are
identical.

When dealing with a fancy user-defined class type, the situation is
different (but I'll get to that further down).

 


You're mixing up terminology.

"int" is a type.
"double" is a type.

"an object" is simply another term for "a variable". However, we only
tend to use "a variable" when we're dealing with something simple like an
int or a double. "object" is used to describe anything, be it an int, a
double, an std::string, or an std::vector<int>.

Here's how you define an object in C++:

    TypeName object_name;

Here's some examples:

    int i;

    char k;

    short b;

    double j;

    std::string str;

    std::vector<int> vec;

    bool n;

As I said, the two forms of initialisation are identical if you're
dealing with an intrinsic type:

    int i = 5; int i(5);

    double k(42.234); double k = 42.234;

If you're dealing with a class which has a constructor however, e.g.:

    class SomeClass {
    public:
        SomeClass(int k) {}

    };

Then:

    SomeClass object = 5;

is interpreted as if it were written as:

    SomeClass object = SomeClass(5);

As you can see, a nameless temporary is created on the right hand side,
and then "object" is copy-constructed from this nameless temporary.
However, a compiler won't bother making a temporary, it will just pass 5
to object's constructor. The caveat though is that even if no temporary
is created, the class must still have a public copy-constructor. Consider
the following:

class SomeClass {
private:

    SomeClass( const SomeClass &original );
    /* Can't copy-construct */

public:

    SomeClass(int) {}

};

int main()
{
    SomeClass obj1(5); /* No problem */

    SomeClass obj2 = 5; /* Won't compile */
}

I myself advocate the following:

Use the "equals" form when dealing with an intrinsic type.
Use the "brackets" form when dealing with a fancy class.

-Tom1s