Why Can't We Declare Object of a Class Inside the Same Class

why can't we declare object of a class inside the same class?

You can do

class A {
A* a;

because it doesn't require knowing the size of A.

Can we declare an object of a class inside a function of the same class in C++?

You can instantiate, modify and return an object of the same class within a member function, no matter if static or not. Here is some nonsensical but working code that shows you some possibilities.

class Train {
int a;

Train(int a) : a(a) {}

static Train addTrain() {
Train t = Train(4);
t.a = 2;
return t;

void add(int num) {
Train t = Train(num);
this->a += t.a;

why can't we declare object of a class inside the same class in C++ but it is allowed in Java?

In Java, if you have A a;, a is a reference to an object of class A. In C++, it's not a reference, it's a complete object.

So the resulting object in C++ would be of infinite size, which isn't very practical.

When is it OK to create object of a class inside a method of that class?

Is it not strange to create an object in the definition of the same class
than in response the object create a new object then this new object
create another and the infinite loop begins

No, the main method only runs once when you run your program. It will not be executed again. So, the object will be created only once.

Think of your main method to be outside your class. Which creates an instance of your class, and uses the instance created. So, when you create an instance from main method, the constructor is invoked to initialize the state of your instance, and then when the constructor returns, the next statement of your main method is executed.

Actually, you can consider main method not to be a part of the state of the instance of your class.

However, had you created the instance of your class inside your constructor (say 0-arg), and the reference as instance reference variable, then that will turn into an infinite recursion.

public class A {
private A obj;
public A() {
obj = new A(); // This will become recursive creation of object.
// Thus resulting in StackOverflow

Why is it not allowed to define a class object in the same class?

A class can't contain an instance of itself because that would make the instances take up an infinite amount of space.

Think about it: you create a LinkScreen object… which contains another LinkScreen object… which contains another LinkScreen object, which contains yet another, and so on.

Or, to look at it another way, what's the size of a LinkScreen object? Well, it's the size of the variables it contains: a Link* (typically 4 or 8 bytes) plus the size of a LinkScreen object. But how big is that? Well, it's the size of a Link* plus the size of a LinkScreen. You can see the infinite recursion here.

You can only create an instance of a type that's "complete", which for a class means that the compiler has seen the closing brace of the class definition. That prevents you from putting an instance within the class itself. You can create a pointer to an incomplete type, though; it's OK for a LinkScreen object to contain a LinkScreen* variable.

How does creating a instance of class inside of the class itself works?

There is absolutely no problem in creating instances of a class in the class itself. The apparent chicken-or-egg problem is solved in different ways while the program is being compiled and when it is being run.


When a class that creates an instance of itself is being compiled, the compiler finds that the class has a circular dependency on itself. This dependency is easy to solve: the compiler knows that the class is already being compiled so it won't try to compile it again. Instead, it pretends that the class already exists generates code accordingly.


The biggest chicken-or-egg problem with a class creating an object of itself is when the class does not even exist yet; that is, when the class is being loaded. This problem is resolved by breaking class loading into two steps: first the class is defined and then it is initialized.

Defining means registering the class with the runtime system (JVM or CLR), so that it knows the structure that objects of the class have, and what code should be run when its constructors and methods are called.

Once the class has been defined it is initialized. This is done by initializing static members and running static initializer blocks and other things defined in the particular language. Recall that the class is already defined at this point, so the runtime knows what objects of the class look like and what code should be run to create them. This means there's no problem whatsoever to create objects of the class when initializing it.

Here's an example that illustrates how class initialization and instantiation interact in Java:

class Test {
static Test instance = new Test();
static int x = 1;

public Test() {
System.out.printf("x=%d\n", x);

public static void main(String[] args) {
Test t = new Test();

Let's step through how the JVM would run this program. First the JVM loads the Test class. This means that the class is first defined, so that the JVM knows that

  1. a class called Test exists and that it has a main method and a constructor, and that
  2. the Test class has two static variables, one called x and another called instance, and
  3. what is the object layout of the Test class. In other words: what an object looks like; what attributes it has. In this case Test doesn't have any instance attributes.

Now that the class is defined, it is initialized. First of all, the default value 0 or null is assigned to every static attribute. This sets x to 0. Then the JVM executes the static field initializers in the source code order. There are two:

  1. Create an instance of the Test class and assign it to instance. There are two steps to instance creation:
    1. First memory is allocated for the object. The JVM can do this because it already knows the object layout from the class definition phase.
    2. The Test() constructor is called to initialize the object. The JVM can do this because it already has the code for the constructor from the class definition phase. The constructor prints out the current value of x, which is 0.
  2. Set static variable x to 1.

Only now the class has finished loading. Notice that the JVM created an instance of the class, even though it was not fully loaded yet. You have proof of this fact because the constructor printed out the initial default value 0 for x.

Now that the JVM has loaded this class, it calls the main method to run the program. The main method creates another object of class Test - the second in the execution of the program. Again the constructor prints out the current value of x, which is now 1. The full output of the program is:


As you can see there is no chicken-or-egg problem: the separation of class loading into definition and initialization phases avoids the problem completely.

What about when an instance of the object wants to create another instance, like in the code below?

class Test {
Test buggy = new Test();

When you create an object of this class, again there is no inherent problem. The JVM knows how the object should be laid out in memory so it can allocate memory for it. It sets all the attributes to their default values, so buggy is set to null. Then the JVM starts initializing the object. In order to do this it must create another object of class Test. Like before, the JVM already knows how to do that: it allocates the memory, sets the attribute to null, and starts initializing the new object... which means it must create a third object of the same class, and then a fourth, a fifth, and so on, until it either runs out of stack space or heap memory.

There is no conceptual problem here mind you: this is just a common case of an infinite recursion in a badly written program. The recursion can be controlled for example using a counter; the constructor of this class uses recursion to make a chain of objects:

class Chain {
Chain link = null;
public Chain(int length) {
if (length > 1) link = new Chain(length-1);

C++same class as member in class

The reason is that the type of the member m_Mother has incomplete type at the point it is declared.

If you think about it. If it would have worked, you would create an object with an object inside with the same type, which in turn always have an object of the same type inside (and so on). The object would in a sense have infinite size.

One solution is to keep a pointer to the parent class instead.

class clsNode
clsNode* m_Mother;
void setMother(clsNode* uNode){ m_Mother=uNode; }

If you would like to have all parents always be alive during the lifetime of their children, you could use a shared pointer instead of a raw pointer.

class clsNode
std::shared_ptr<clsNode> m_Mother;
void setMother(std::shared_ptr<clsNode> uNode){ m_Mother=uNode; }

If you go with this solution you would originally create your objects with make_shared

How to create object inside the same python class

As @g.d.d.c mentioned

You can't have a class variable that's an instance of the class you're defining. The class doesn't exist at the time when you're attempting to create an instance of it.

However, if you do indeed want to do something like this, here's a work-around:

Change the line

   obj1 = Employee("Mayank",6000)


Employee.obj1 = Employee("Mayank",6000)

Note: I don't think that you would want to write code like this, however. In this case, it makes more sense to create an object of the class outside the class. For that, it would only be an unindent of the line.

Related Topics

Leave a reply