is this destructor valid in c++?

1. 开发者_开发百科

   String::~String() { std::cout<<"String()" <<std::endl; }

   I wonder if this implementation of destructor is valid?

2. And another question about const member function qualifier, I know the const function can not change the variables in this class, it just read-only. If there is no other weird questions about it, I think I can understand it, but I saw some questions as following:

   • It allows the invocation of a non-const member function for the object pointed to by this

   • It guarantees that only mutable member variables of the object pointed to by this can be changed

   • It ensures that all constants remain invariable

   • It prevents inheritance

   • It allows changes to the state of the object pointed to by this

Based on my understanding, it is very hard to check which one is right, so I guess all of them are wrong?

1. The destructor is technically just another function, there doesn't seem anything wrong syntactically with this destructor to me, so it seems valid

2. That is all there is to const member functions, you cannot modify the data. These functions are automatically invoked by a const instance of the class. So if you have two functions with the same signature except for const-ness, it will chose the const version for const instances, and for non-const instances, it will depend on how you use it that determines which version is invoked

   a) you cannot invoke non-const member functions within a const member function

   b)Correct

   c) correct

   d) i'm unsure what you mean by preventing inheritance. IF you declare a function as virtual, const or not, it is inherited and can be overridden by subclasses

   e) in const member functions, all data is considered const, unless declared a mutable.

Yes, that is a valid destructor.

const does not prevent inheritance. Nor does it bring about invariant behavior in the class's methods.

This question is actually multiple questions, though.

I recommend reading C++ FAQS.

I wonder if this implementation of destructor is valid?

There is nothing wrong with the destructor. But the question is: is that all you want to do in the destructor? Destructor is usually used to free the resources object holds when its alive; so it should free them when its going to die, so that others can use them. If it doesn't free them, then those resources will not be used by others as long as the program runs. Such a situation is usually referred to as Resource Leak, and if the resource is memory, its called Memory Leak.

Regarding question 2.

A nice way to think of member function cv qualifiers is to think of them as qualifiers on the 'this' pointer.

For example, if we wrote some C++ code in C:

class A
{
public:
  void f1 ();
  void f2 () const;

private:
  int i;
};

This is the same as the following C code:

struct A
{
  int i;
};

void f1 (A * const this);        // Non const member
void f2 (A const * const this);  // Const member

Another important thing to understand is that when you refer to a non static data member of a class, (*this). is implicitly added to it:

void A::f1 ()
{
  i = 0;         // This and the next line have the same meaning
  (*this).i = 0;
}

When the member function is const, the this pointer is declared as pointing to a const object:

void A::f2 () const
{
  (*this).i = 0;  // Error '*this' is const, so cannot modify (*this).i
}

One of the conclusions from this, and something that people sometimes find is surprising, is that a const member function can still modify data pointed to by a member pointer. For example:

class A
{
public:
  void f () const
  {
    *i = 0;
  }

private:
  int * i;
};

This looks wrong, but it's actually fine. (*this).i is const and so you would not be able to change what i points to, but i is still a pointer to a non const int and so we can modify the value pointed to by i.