Object creation differences

Question

What is the difference between the 2 following methods to create an object?

Test* t = new Test();

and

Test* t;

Your answers to second sample match with what i thought it would do (no object is created) But

class Test {
        public:
                void bla(void) {
                        std::cout << "test" << std::endl;
                };
};

int main(void) {
        Test* test;
        test->bla();
}

gives me the output "test"... So there is actually an Object

Are you sure you didn't mean `Test t` in that second snippet? — Lightness Races in Orbit, Jun 08 '11 at 11:49
You mean the difference between creating an object and not creating an object? — Bo Persson, Jun 08 '11 at 12:16

score 7 · Answer 1 · edited May 23 '17 at 12:12

The first one does 4 things:

create pointer to Test
allocate memory and creates Test object (note, that it's Test, not test )
the new object is value initialized, because of the () - see Do the parentheses after the type name make a difference with new? for more information
initializes the pointer to point to the created object

The second one just creates pointer to Test. And it's not initialized.

@yogi - for your edit - this is totally Undefined Behavior, as the pointer is uninitialized. And no, it's not an object. See C++ function called without object initialization for more information.

+1, you can also add that it in first case it's value initialized using `()` after `Test`. — iammilind, Jun 08 '11 at 11:55

score 4 · Answer 2 · answered Jun 08 '11 at 11:42

4

The second one doesn't create any object at all and trying to access it will result in Bad Things™.

answered Jun 08 '11 at 11:42

Puppy

144,682
38
256
465

Tristram Gräbener · Answer 3 · 2011-06-08T15:16:00.730

This is a pointer, allocated on the stack, and uses 32 or 64 bits of memory.

Test * t;

This will create an object of type Test on the heap (an you need to desalocate it)

t = new Test();

This will create an object of type Test on the stack (no need to desalocate it. It will disapear as soon as you exit the current context)

Test t2;

Edit

Your example works because the compiler optimized you code : it notices that you don't use any member, so it could doesn't make the effort you look for the instance.

score 1 · Answer 4 · answered Jun 08 '11 at 11:43

1

The first one is a method to create an instance of an object.

The second on is not a method to create an instance of an object. It merely declares a pointer, which remains uninitialised.

answered Jun 08 '11 at 11:43

johnsyweb

136,902
23
188
247

score 1 · Answer 5 · answered Jun 08 '11 at 12:13

After your update: The reason that it still successfully calls bla() is just undefined behaviour. Because that's exactly what the C++ Standard defines what is happening when you work with unsafe memory (in this case some arbitrary address that your pointer is pointing to) - the behaviour is undefined.

Alok Save · Answer 6 · 2011-06-08T12:24:44.843

 Test* test;         
 test->bla();

As other answers have stated, Test* test does not create any object. It is a uninitialized pointer to Test. It is not pointing to anything valid unless it is initialized to point to a valid Test object.

Dereferencing an Uninitialized pointer like you are results in a Undefined Behaior.
In your case it does not crash because you are not referring this inside bla().
Nevertheless its still undefined behavior to dereference unitialized test.

To reiterate the above point, the following example will mostly crash.

#include<iostream>
class Test 
{
    public:
        int i; 
        void bla(void) 
        {
            std::cout << "test" << std::endl;
            std::cout << "test->i" << this->i <<std::endl;
        }
};

int main(void) 
{
    Test* test;
    test->bla();
    return 0;
}

score 0 · Answer 7 · answered Jun 08 '11 at 12:20

As others already said, you're just lucky that the undefined behaviour that you trigger happens to look like what you thought you want (essentially because your Test::bla() is almost like a global free function). To see your example crash and burn, just add some non-trivial class members:

class Test {
public:
  void bla(void) {
    std::cout << "test: " << x << std::endl;
  };
  int x;
};

You can think of your original example as a free function

void bla(Test * p) { std::cout << "test" << std::endl; }

which you just happen to call with a garbage parameter, but since you don't use the parameter, nothing bad happens. In my modified example, we try to access p->x and die.

Object creation differences

7 Answers7

Linked