C/C++拷贝构造函数和朋友成员

一.拷贝构造函数
拷贝构造函数是一种特殊的构造函数
（1）它是构造函数，所以函数名是类名，没有返回值
（2）它是特殊的构造函数，所以它的参数形式是固定的
class Object{
public:
Object(const Object& other);
};

拷贝构造函数的定义：以一个对象为蓝本，来构造另一个对象。
Object a;
Object b(a);//或者写成Object b = a;
b 是 a 的一个拷贝/备份，二者内容完全相同

拷贝构造函数从来不显式的调用，都是由编译器隐式的调用。
有以下三种情况：
（1）：定义对象
Object a;
Object b(a);//或者写成Object b = a;
（2）：动态创建对象
Object a;
Object* p = new Object(a);
（3）：函数的传值调用
void test(Object obj)

class Object{
 	public:
 		Object(int a,int b)
 		{
 			this->a = a;
 			this->b = b;
		 }
		 Object(const Object& other)
		 {
		 	printf("in copy constructor....\n");
		 	this->a = other.a;
		 	this->b = other.b;
		 }
	private:
		int a,b;
 };
 
 void test(Object obj)
 {
 	
 }
 int main()
 {
 	Object obj(1,2);
 	
 	test(obj);
// 	Object tdz(a);
// 	Object* p = new Object(obj);
// 	
// 	delete p;
 	return 0;
 }

注意：
（1）区分构造和赋值
构造：
Object a;
Object b = a ;//此为构造，在创建对象的时候赋予初值，拷贝构造函数被调用
赋值：
Object a;
Object b;
b = a; //此为赋值，不会调用构造函数
（2）可以访问同类对象的private成员
Object(const Object& other)
{
this->a = other.a;
this->b = other.b;
}
就像刚才的那个例子一样。

当我们没有书写拷贝构造函数的时候，编译器会为我们添加一个默认的拷贝构造函数
默认的拷贝动作：将每一个成员逐个拷贝。
二.深度拷贝和浅拷贝

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

//当出现下列情况时，需要添加拷贝构造函数

class Text{
	public:
		Text(const char* str)
		{
			//申请一块内存，保存此字符串 
			m_size = strlen(str) + 1;
			m_buf = new char[m_size];
			strcpy(m_buf,str);
		}
		Text(const Text& other)//深度拷贝 
		{
			m_size = other.m_size;
			m_buf = new char[m_size];
			strcpy(m_buf,other.m_buf);
		} 
//		Text(const Text& other)//浅拷贝 
//		{
//			m_size = other.m_size;
//			m_buf = other.m_buf;
//		} //并不符合面向对象的思想，问题还是存在。 
		~Text()
		{
			//释放此字符串 
			delete [] m_buf;
		}
		const char* GetText()
		{ 
		    return m_buf;
		}
	private:
		int m_size;
		char* m_buf;
};
 
 int main()
 {
 	Text t1("hello world!");
 	//printf("%s\n",t1.GetText());
    Text t2(t1);//此时会出现问题，t1和 t2都指向同一项m_buf的内存，两次delete会出错，此时就需要使用深度拷贝。 	
 	return 0;
 }

三.朋友成员

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

//引例
class Object{
	friend void print(Object* p) ;//解决无法访问的问题 
	public:
		Object(int v):value(v)
		{
			
		}
	private:
		int value;
}; 
void print(Object* p)
{
	printf("value: %d\n",p->value);
}

int main()
{
	Object obj(10);
	print(&obj);
	
	return 0;
}

用friend关键字可以将一个全局函数或者一个类申明为该类的“朋友”。
friend class Something
friend的申明:位置自由，一般放在类体大括号的最前头
可以无限制的访问该类的所有成员，但是朋友关系是单向的 Something 类可以访问Object类，反过来不行。