Thread: A Question On Reference Type

That line (in green) is completely useless since you're calling the default constructor twice. Just do this:

I know that I am exactly calling constructor in different ways.
[EDIT] Sorry you are right I thought you are saying something else.
When constructor has no parameter we should use TestClass t; But not TestClass t();
When for example it takes an int we should write TestClass t(intA);

Why do you need a cast?

QUOTE]What type cast?[/QUOTE]
To cout << this; in constructor

stack is a part of memory where local variables and arrays are stored in LIFO. It is also used for passing function parameters.

stack is a part of memory where local variables and arrays are stored in LIFO. It is also used for passing function parameters.

Then you have answered your own question. t is a local (or perhaps more accurately in the context of the question, an automatic) variable.

C++ has three kinds of storage: static, dynamic and automatic.

They are typically mapped to the OS's .data/.bss, heap and stack.

What kind of storage an object uses is generally very obvious:
1) Globals, static class members and static locals are in static storage.
2) Everything allocated by normal new, the malloc family, and std::get_temporary_buffer is in dynamic storage. There may be additional, implementation-specific means of obtaining memory in dynamic storage (e.g. HeapAlloc in Win32).
3) Everything else - including temporaries, obviously - is automatic storage.

I know. Use void*.

Thanks. I should practice programming with extensions turned off or at least WL 4. Note the edit in my former post.
But I still don't know why by calling constructor, class takes place in stack.

But I still don't know why by calling constructor, class takes place in stack.

You're mistaking the cause here. The object is on the stack because it's not a global or on the heap. The constructor is called because it's an object.

You're mistaking the cause here. The object is on the stack because it's not a global or on the heap. The constructor is called because it's an object.

It is not anywhere. You mean by defining the class, it will be placed on the stack?

No.
You create it inside a function, so it isn't global.
You don't create it with static, so it's not a static variable.
You don't create it with new, so it's not on the heap.
What's left? The stack! It's created on the stack.
Everything that is not global, static or on the heap is placed on the stack!

Class definition has nothing to do with it.

You mean by defining the class, it will be placed on the stack?

Careful with your terminology. This is a class definition:

Code:

class Foo
{
 int m1;
public:
  void bar();
};

Careful with your terminology. This is a class definition:

I exactly mean it.

By defining a class it is nowhere. It is just for compiler. If its true. How its constructor can be called?

When we define a function in a file its code will be loaded into memory each time programs executes. But when its a member function of a class it is nowhere unless it has been defined static or the class has been instantiated.

The functions (where the code lies) of the class is called the implementation.
Also, it's true that the code in the class, the functions, are indeed created and put in memory, but what has that to do with the instance being created on the stack? Btw, all the member data is placed on the stack, but the function aren't, because they're code.

By defining a class it is nowhere. It is just for compiler. If its true. How its constructor can be called?

It's called per instance.