copy constructor

[Danishx83]

class P {
  public:
      P() {}
      ~P() {}

      P(P const & p) {      //<--- Question 1
          setX(p.getX());   //<--- Question 2
          setX(p.x);        //<--- Question 3
          x = p.x;          //<--- Question 3
      }

      void setX(int i) {
          x = i;
      }

      int getX() {
          return x;
      }

  private:
      int x;
};

Question 1 Whats the difference between P(P const & p) and P(const P & p) ?
Question 2 Why this does not work ?
Question 3 Why does this work, (accessing the private data memeber directly) ?

[vlad from moscow]

Q1. There is no difference between these two declarations.
Q2. It does not work because you are trying to call non-const member function for const object (because you declared the parameter as a const reference). If you will rewrite function getX as

int getX() const
{
          return x;
}

it will work.

Q3. It works because the objedts are of the same type.

[Peter87]

Answer 1 There is no difference
Answer 2 Because getX is not const so you can only call it on non-const objects. If you define getX as this it will work

int getX() const {
	return x;
}

Answer 3 Because all member functions of P has access to the private member's of P.

[Danishx83]

@vlad from moscow
@Peter87

Thank you


Can I use

int const getX() {
	return x;
}

or

const int getX() {
	return x;
}

instead of

int getX() const {
	return x;
}

[Peter87]

No. The first two has return type const int.

[vlad from moscow]

In the declaration

int getX() const;

const belongs to the implicit object parameter this as if you would declare

int getX( const P * );

[Danishx83]

I think I got it, let me experiment around, then will get back.

@vlad from moscow
@Peter87

Thank you for your help

[Danishx83]

So let me put down my understanding for the help of any one like me.

In a same class i.e

Same class
Derived class
Friend class

you can access the private members of that class i.e

Same class
Parent class
Base class

[Danishx83]

C++ is just very strict about the type

if you tell it that you will get return_type / argument_type , then the function must return the exact return_type / argument_type, for C++

type != const type