Thread: Public: ~Class() is allowed?

Is the following code allowed:

Code:

public: ~Class()
{
    blahblah
}

I coded it inside one of my class and I executed it in my startup program. It works perfectly.

From what Ive read from a book, it says class destructor forbids any kind of public in front of the tilde ~.

Can someone explain? Thanks in advance

Edit: I changed the "P" to small "p". Ive some typo error back then.

That shouldn't compile since C++ is case sensitive.
But this:

Code:

class Class
{
public: ~Class() {}
};

is the same as this:

Code:

class Class
{
public:
   ~Class() {}
};

In this case, Public is just a label (that you could use with goto), not a namespace or a class or an actual public declaration or anything like that. (I wouldn't think you could label a function, but if you say it works who am I to say no.) I would think this would have to be inside the class declaration for ~Class by itself to make sense. EDIT: And with a small p, none of this part matters! Yay!

Even if it was lowercase, I don't see what the problem is, exactly. Wouldn't a destructor, if you defined it, have to be public to work?

Did you create a default constructor? If not the compiler might be implying a default constructor before ~Class(); so then it would be compiling correctly and not have any run time errors. This is just my wild guess, though, so don't take it as truth.

Originally Posted by Lincoln_Poh

Nono, cpjust, my main problem is to ask, what's the difference between:

Code:

public: ~class()

and

Code:

 
~class()

I want to know does C++ allow us to preface public or any kind of other words in front of the tilde ~class ?

For my case here, I have coded it inside my startup program, and it ran perfectly. I want to know why does it ran perfectly. The book which Im reading said that C++ forbids public: in front of the class destructor...

Putting public: infront of or above makes no difference, as long as there is some whitespace between them.

If you have this:

Code:

class Class
{
   ~Class();
};

Then your destructor would be private, the same as this:

Code:

class Class
{
private:
   ~Class();
};

and if your destructor is private, you cannot instantiate that class.

Originally Posted by cpjust

if your destructor is private, you cannot instantiate that class.

You could if it's a singleton.

Originally Posted by King Mir

You could if it's a singleton.

Well sure, you can create a pointer to it, but not a regular stack variable.
It doesn't even need to be a singleton, as long as you provide a Delete() method:

Code:

class Test
{
   ~Test() {}

public:
   void Delete() { delete this; }
};

int main()
{
   Test* pT = new Test;

   pT->Delete();
   return 0;
}

Originally Posted by Lincoln_Poh

Omg, everyone here explain things until so profound. Can someone simplify things so its easier for me to at least understand 80% of it >.<?

My question again is: Does C++ allow us to put "public:" in front of a class destructor? Ive no idea what in the world is a default. My problem is destructor, not contructor...

Thanks in advance...

Yes, you can put public: or protected: or private: anywhere you want inside a struct or class. There's nothing magical about them.

It seems that in C# every method must have a modifier (private/public), except destructors which are called by the garbage collector.

This doesn't apply in C++. The modifiers need not be added to every method, the private or public keyword applies to all methods that follow it until a different modifier appears or the end of the class declaration.

In C++, normally destructors are public, since otherwise you can't create stack instances, or call delete on a dynamically allocated instance. But you may sometimes make it private to control who can destroy instances.

However, destructors are practically never called explicitly by you. Even though they are public, you must never do the following:

Code:

#include <iostream>

class X
{
    public:
    ~X() {}
};

int main()
{
    X x;
    x.~X();  //very wrong
}

Originally Posted by Lincoln_Poh

Ive no idea what in the world is a default.

A default constructor looks like this

Code:

class foo
{
     private:
          int data;
     public:
          foo(); //THIS IS A DEFAULT CONSTRUCTOR
          foo(int, int); //another constructor, but with arguments
          ~foo(); //destructor
};

You can have multiple constructors, where each one accepts a different argument. A default one basically means if the person initializes the class without passing it any arguments then it will do something (usually set int "data" to something) by default.

Code:

foo fooClass; //uses the default constructor to set the int "data"
foo fooClass2(5,10); //uses the other constructor to set other things.