Q:

Can I write different copyCtor for const and non-const instances?

I have the following problem:
I have a class which should do this:
Obj o;
Obj o1(o), o1=o; // deep-copies
const Obj c(o), c=o; // deep-copies
const Obj c1(c), c1=c; // shallow-copies
Obj o2(c), o2=c; // deep-copies

How can I do this preferably without inheritance? (I mean I would do Const_obj inheriting from Obj otherwise.)
EDIT:
Using o.clone() directly is not an option because then I could easily introduce bugs by accidentally not cloning.
EDIT:
Finally, there is a proper, complete solution with lazy evaluation using the idea from Effective C++ by Scott Meyers. Check out my answer below.

A:

No, you can't.

A constructor can not be cv-qualified, so you can't force it to construct a const object. 
The return type of a function (including operators) is not a part of it's signature, so you can't overload a function with just changing it's return type.

Also, if it was possible, I would find it really confusing. Just make methods that suit your needs, and name them in an unambiguous way.

A:

After reading Effective C++ by Scott Meyers, the following is a solution:
define a template which does a lazy evaluation (with reference counting):
class Obj : private lazy<Obj_data>{};

and the lazy stores the Obj_data privately, has protected accessors, one for modification, one for read-only access.
The modifier accessor first deep-copies the Obj_data if necessary, then hands over the reference to the data. The read-only accessor just returns a const reference.
The overall cost of this is storing 2 extra pointers (one for the data and one for the counter) and a counter.
Implementation is something like this:
class lazy{
protected:
  lazy(const lazy&obj){lazy_copy(obj);}
  //(the required constructors, operator= ...)

  // accessors:
  const Obj_data& data() const {return *od;}
  Obj_data& mod_data() {make_private(); return *od;}
private:
  void lazy_copy(const lazy& obj);
  void make_private(); // this does the actual deep-copy, as late as possible.
private:
  counter*;
  Obj_data* od;
};

So, reading and modifying an attribute of Obj goes
void Obj::method(){
   cout << data().some_attribute;    // simple read
   mod_data().i = 10;                // simple modify
   const Obj_data& const_d = data(); // assignable for lots of read-outs
   Obj_data& var_d = mod_data();     // assignable for lots of modifications.
}

Note that you can only use data() in a const member as mod_data() is a non-const function in the class, so this solution is completely safe with little overhead.
Theory background: the desired behaviour in the question is an implementation detail, does not concern the client. Therefore we solve it by private inheritance.

