CODEWITHSUNDEEP
c++copyconstructor
vj01
vj01

Reputation: 663

Copy constructors - c++

Can I write a copy constructor by just passing in a pointer instead of the const reference? (Would it be ok if I make sure that I am not going to change any values though?)

Like so:

SampleClass::SampleClass(SampleClass* p)
{
 //do  the necessary copy functionality
}

instead of:

SampleClass::SampleClass(const SampleClass& copyObj)
{
//do the necessary copy
}

Thanks in advance.

Thanks everyone. So, if I write a constructor that takes in a pointer( and thought that's my copy constructor), the compiler would still supply with the default copy constructor in which case my constructor( which i thought was my copy constructor) would not be called and the default copy constructor would be called. Got it.

Upvotes: 10

Views: 5265

Answers (9)

Rob
Rob

Reputation: 1

You can write a perfectly valid copy constructor, and still be able to pass a reference that is NULL. You can test for NULL, but only if you do not use constructor initialization lists.

Example:

MyClass::MyClass( MyClass const& MyClassCopy )
: somevar( MyClassCopy.somevar ) // <- the init list goes here.
{
   // If MyClassCopy is NULL, the initialization above is doomed!
   // However we can check for NULL in the constructor body but
   // the initialization list must be removed ...
   if (&MyClassCopy == NULL ) throw( std::runtime_error("NULL pointer!"));
   somevar = MyClassCopy.somevar;
}

// I'll now do some very dangerous programming to
// demonstrate one way that a NULL can get through ...
MyClass* P = NULL;
MyClass A( *P ); // Bang, you're dead!

As far as I know, there's no way to check for a NULL from inside the initialization list, so if you think you could end up with a situation where a NULL gets through, you have to test for it in the constructor body and do the initializing from there.

Don't forget there's a few gotchas with ::operator=() function to be aware of ...

Upvotes: -1

G S
G S

Reputation: 36818

Yes, you can write a constructor that takes a pointer to the object. However, it cannot be called a copy constructor. The very definition of a copy constructor requires you to pass an object of the same class. If you are passing anything else, yes, it's a constructor alright, but not a copy constructor.

Upvotes: 19

JohnMcG
JohnMcG

Reputation: 8805

The copy constructor is implicitly used in two cases:

  • When an instance of your class is passed by value to a function.
  • When an instance of your class is returned by value from a function.

As others have mentioned, you can write a constructor with the signature described (or with a const pointer), but it would not be used in either of the above cases.

Upvotes: 1

David Rodr&#237;guez - dribeas
David Rodr&#237;guez - dribeas

Reputation: 208323

Besides the fact that it would not be a copy constructor and the compiler will generate the copy constructor unless you explicitly disable it, there is nothing to gain and much to loose. What is the correct semantics for a constructor out of a null pointer? What does this add to the user of your class? (Hint: nothing, if she wants to construct out of a heap object she can just dereference the pointer and use the regular copy constructor).

Upvotes: 2

Loki Astari
Loki Astari

Reputation: 264331

You can write a constructor that takes a pointer as an argument.
But the copy constructor is the name we give a specific constructor.
A constructor that takes a reference (preferably const but not required) of the same class as an argument is just named the copy constructor because this is what it effectively does.

Upvotes: 4

Brian Ensink
Brian Ensink

Reputation: 11218

You can write a constructor like that but its not technically a copy constructor. For example the STL containers will still use the compiler generated copy constructor (the compiler generates one because you didn't write one).

Upvotes: 1

Bill the Lizard
Bill the Lizard

Reputation: 405715

A copy constructor needs a reference because a value parameter would require making a copy, which would invoke the copy constructor, which would make a copy of its parameter, which would invoke the copy constructor, which ...

Upvotes: 1

oz10
oz10

Reputation: 158264

By definition, the copy ctor uses a const reference. While there is nothing stopping you from writing a ctor that takes a pointer, it raises some problems not present when using a reference - e.g., what should/can happen if a null pointer is passed in?

Upvotes: 1

C. K. Young
C. K. Young

Reputation: 222993

No. Copy constructors must take a reference, not pointer, if it's to be useful for passing-by-value, etc.

Upvotes: 1

Related Questions