invalid use of 'class ...'

Hi, I am writing my very first C++ program using classes. I am trying to doit in small steps so I can catch the error early and quick...
I have defined the class, and I tried to place some calls for methods from that class in main. But I get this error: invalid use of 'class Stack'
I've checked what I could, and I really do not know why I get this.
So, my class is defined as such:

Code:

---

/* some includes, namespace std etc. */
class Stack {
      private:
              int *ptr;
              int top;
              int array[MaxStack];
              int tmp;
      public:
            void Stack::init() { top = -1; }
            Stack::Stack() { ptr = new int[MaxStack];
                          top = 10;
                          ptr = array;
                          for (int i = 0; i < 10; i++)
                            array[i] = 0;
                        }
/* some more methods here */
};
int main()
{
  Stack s;

  s.init();
  s.Stack(); /* the line error indicates */

  return 0;
}

---

What am I doing wrong?

>> s.Stack(); /* the line error indicates */

What are you trying to do there?

Sorry, my error. This is just a default constructor. The 3 in brackets comes from my other constructor. Still, same error.

Why are you calling the default constructor there? What are you trying to do? The default constructor is automatically called when you declare the variable s.

So what is the purpose of writing your own constructors? How can you use them??? If I have a default constructor and my own, I was told I need to call the constructor. So I did, and it gives me errors... Now I am confused.

The constructor that you wrote is called automatically when you declare the variable s. So it is already being used. You never actually "call" a constructor, one is just called for you when you create an instance of your class. In this case, you created an instance with the variable s. Then you called init(). At that point you can use your stack.

So, if I create another instance of the class Stack, lets say s1, and do not call init() on it, I can use my other constructor?

In general here is an idea

Code:

---

class MyClass
{
public:
int m_health;
int m_damage;

MyClass( Health = 100, Damage = 50 );  // constructor
};

// use constructor outside main

MyClass::MyClass ( Health, Damage )
{
m_health = Health;          // assign members values
m_damage = Damage;
}

main()
{
}

---

>> So, if I create another instance of the class Stack, lets say s1, and do not call init() on it, I can use my other constructor?

What "other" constructor. In the code you posted, there is only one constructor for the class Stack. It will be called each and every time you create an instance of the Stack type.

You can add additional constructors. For example, you might add a new constructor that takes an initial size. Once you have more than one constructor available, you can pick which one you want to have called depending on how you declare the new variable.

As far as the init() function, it isn't necessary in this case, you should remove it from your attempt to understand the constructors. The constructor you have written initializes the class on its own, so there is no real need for an init function.

OK, so f I have my own constructor

Code:

---

Stack::Stack(int n) { top  = n;
                              ptr = new int[MaxStack];
                              ptr = array;
                              for(int i = 0; i < top; i++)
                              array[i] = 0;
                            }

---

Is it OK to use it?

Yes. To use that constructor instead of the one you have in your first post, you would use

Code:

---

Stack s1(3);

---

(or whatever you want instead of 3).

Although you wouldn't want to use the code you have in that particular constructor because it contains an error (memory leakage).

Thanks, Daved and hk_mp5kpdw. I think I can handle exploring some more (for now) by myself. You were of great help, I appreciate it.

See if this helps:

Code:

---

#include <iostream>
using namespace std;

class Simple
{
private:
        int start;

public:
        Simple() //default constructor
        {
                start = 1;
        }
       
        Simple(int num)
        {
                start = num;
        }

        void show()
        {
                cout<<start<<endl;
        }
};

int main()
{

        Simple s1;  //calls default constructor
        s1.show();

        Simple s2(30);  //calls the other constructor
        s2.show();

        return 0;
}

---

The way the program knows which constructor to call is determined by the line that creates the object:

Simple s2(30);

That line wants to create the object by sending one int argument to a constructor, so the compiler looks for a constructor that has one int parameter in its definition, e.g.:

Code:

---

Simple(int num)
{
    //code
}

---

In this line:

Simple s1;

there is no argument listed--not even parentheses like this:

Simple s1(); //error

When you create an object like that, the compiler looks for a default constructor. A default constructor is a constructor that has no parameters in its definition, e.g.:

Code:

---

Simple(/*no parameters in here*/)
{

}

---

If you do not supply a constructor for your class, the compiler will supply an invisible default constructor for you. The default constructor provided by the compiler only creates the objects--it does not initialize the member variables to anything.