C++类与对象基本语法（2）

---

8、拷贝构造函数和拷贝赋值运算符

（1）拷贝构造函数
用一个已有的对象，构造和它同类型的副本对象——克隆。
（2）形如

class X{
	X(const X& that){ ... }
}；

的构造函数称为拷贝构造函数。如果一个类没有定义拷贝构造函数，系统会提供一个缺省拷贝构造函数。缺省拷贝构造函数对于基本类型的成员变量，按字节复制，对于类类型的成员变量，调用相应类型的拷贝构造函数。

#include <iostream>
using namespace std;

class Integer{
public:
	Integer(int data = 0) : m_data(data){}

	void print() const{
		cout << m_data << endl;
	}
	/*
	Integer(const Integer& that) : m_data(that.m_data){}
	*/
	Integer(const Integer& that) : m_data(that.m_data){
		cout << "拷贝构造" << endl;
	}
private:
	int m_data;
};

void foo(Integer i){
	i.print();
}

Integer bar(){
	Integer i;
	return i;
}

int main(){
	Integer i1(10);
	Integer i2(i1);//拷贝构造
	i1.print();
	i2.print();
	Integer i3 = i1;//拷贝构造
	i3.print();
	//Integer i4(1, 2);

	foo(i1);

	Integer i4(bar());
	return 0;
}

（3）在某些情况下，缺省拷贝构造函数只能实现浅拷贝，如果需要获得深拷贝的复制效果，就需要自己定义拷贝构造函数。

#include <iostream>
using namespace std;

class Integer{
private:
	int* m_data;
public:
	Integer(int data) : m_data(new int(data)){}
	~Integer(){
		if (m_data){
			delete m_data;
			m_data = NULL;
		}
	}
	void print() const{
		cout << *m_data << endl;
	} 

	/*Integer(const Integer& that) : m_data(that.m_data){}*///默认的拷贝构造函数，浅拷贝

	Integer(const Integer& that) : m_data(new int(*that.m_data)){}

	void set(int data){
		*m_data = data;
	}
};

int main(){
	Integer i1(10);
	i1.print();
	Integer i2(i1);
	i2.print();
	i2.set(10);
	i2.print();
	i1.print();
	return 0;
}

（4）形如

class X{
	X& operator=(const X& that){
		...
	}
};

的成员函数称为拷贝赋值运算符函数。如果一个类没有定义赋值运算符函数，系统会提供一个缺省拷贝赋值运算符函数。缺省拷贝赋值运算符函数对于基本类型的成员变量，按字节复制，对于类类型的成员变量，调用相应类型的拷贝赋值运算符函数。
（5）在某些情况下，缺省拷贝赋值运算符函数只能实现浅拷贝，如果需要获得深拷贝的复制效果，就需要自己定义拷贝赋值运算符函数。

#include <iostream>
using namespace std;

class Integer{
private:
	int* m_data;
public:
	Integer(int data) : m_data(new int(data)){}
	~Integer(){
		if (m_data){
			delete m_data;
			m_data = NULL;
		}
	}

	/*Integer(const Integer& that) : m_data(that.m_data){}*///默认的拷贝构造函数，浅拷贝
	Integer(const Integer& that) : m_data(new int(*that.m_data)){}

	void set(int data){
		*m_data = data;
	}
	void print() const{
		cout << *m_data << endl;
	} 
    
	/*
	Integer& operator=(const Integer& that){
		m_data = that.m_data;
	}
	*/
	Integer& operator=(const Integer& that){
		if (&that != this){//防止自赋值
			//释放旧资源
			delete m_data;
			//分配新资源，拷贝新数据
			m_data = new int(*that.m_data);
		}
		return *this;//返回自引用
	}
};

int main(){
	Integer i1(10);
	Integer i3(30);
	i3.print();//30
	i3 = i1;//拷贝赋值
	//i3.operator=(i1);
	i3.print();
	i3.set(40);
	i3.print();//40
	i1.print();//40
	i3 = i3;
	return 0;
}

#include <iostream>
using namespace std;

class Nocopy{
public:
	Nocopy(){}
private:
	Nocopy(const Nocopy&);
	Nocopy& operator= (const Nocopy&);
};

void foo(ostream os){
	os << "Hello,World!" << endl;
}

int main(){
	Nocopy n1;
	Nocopy n2 = n1;
	Nocopy n3;
	n3 = n1;
	foo(cout);
	return 0;
}

练习：
（1）用字符指针形式的字符串构造。
（2）拷贝构造和拷贝赋值。
（3）获取字符指针形式字符串的成员函数，类似string::c_str。
说明：不得使用std::string!

#include <iostream>
#include <cstring>
using namespace std;

class String{
public:
	String(const char* str = NULL){
		m_str = new char[strlen(str ? str : "") + 1];
		strcpy(m_str, str ? str : "");
	}
	~String(){
		if (m_str){
			delete[] m_str;
			m_str = NULL;
		}
	}
	String(const String& that){
		m_str = new char[strlen(that.m_str) + 1];
		strcpy(m_str, that.m_str);
	}
	String& operator=(const String& that){
		if (&that != this){
			/*char* str = new char[strlen(that.m_str) + 1];
			delete[] m_str;
			m_str = strcpy(str, that.m_str);*/
			String temp(that);
			swap(m_str, temp.m_str);
		}
		return *this;
	}
	const char* c_str() const{
		return m_str;
	}

private:
	char* m_str;
};

int main(){
	String s1("Hello, World!");
	cout << s1.c_str() << endl;
	String s2 = s1;
	cout << s2.c_str() << endl;
	String s3("Hello, Linux!");
	s1 = s3;
	cout << s1.c_str() << endl;
	return 0;
}

---

9、静态成员

（1）静态成员变量和静态成员函数是属于类的而非属于对象。
（2）静态成员变量，为多个对象所共享，只有一份实例，可以通过对象访问也可以通过类访问，必须在类的外部定义并初始化。
（3）静态成员变量本质上与全局变量并没有区别，只是多了类作用域的约束，和访控属性的限制。

class Account{
private:
	string m_name;
	double m_balance;
	static double m_rate;
};

（4）静态成员函数，没有this指针，无法访问非静态成员。

#include <iostream>
using namespace std;

class A{
public:
	static int m_i;
	static void foo(){
		cout << "foo:" << m_i << endl;
		//m_d = 3.14;
		//bar();
	}
	void bar(){
		m_i = 100;
		foo();
	}
};
int A::m_i = 1;

int main(){
	A::m_i = 10;
	A a1,a2;
	cout << ++a1.m_i << endl;
	cout << a2.m_i << endl;

	A::foo();
	a1.foo();
	a1.bar();
	return 0;
}

（5）单例模式
饿汉模式和懒汉模式。

#include <iostream>
using namespace std;

//饿汉模式
class Singleton{
public:
	static Singleton& getInst(){
		return s_inst;
	}	
private:
	Singleton(){}
	Singleton(const Singleton&);
	static Singleton s_inst;
};
Singleton Single::s_inst;

int main(){
	Singleton& s1 = Singleton::getInst();
	Singleton& s2 = Singleton::getInst();
	Singleton& s3 = Singleton::getInst();
	cout << &s1 << ' ' << &s2 << ' ' << &s3 << endl;
	return 0;
}

#include <iostream>
using namespace std;

//懒汉模式
class Singleton{
public:
	static Singleton& getInst(){
		if (!m_inst)
			m_inst = new Singleton;
		++m_cn;
		return *m_inst;
	}
	void releaseInst(){
		if (m_cn && --m_cn == 0)
			delete this;
	}
private:
	Singleton(){
		cout << "构造：" << this << endl;
	}
	Singleton(const Singleton&);
	~Singleton(){
		cout << "析构：" << this << endl;
		m_inst = NULL;
	}
	static Singleton* m_inst;
	static unsigned int m_cn;
};
Singleton* Singleton::m_inst = NULL;
unsigned int Singleton::m_cn = 0;

int main(){
	Singleton& s1 = Singleton::getInst();
	Singleton& s2 = Singleton::getInst();
	Singleton& s3 = Singleton::getInst();
	cout << &s1 << ' ' << &s2 << ' ' << &s3 << ' ' << endl;
	s1.releaseInst();
	s2.releaseInst();
	s3.releaseInst();
	return 0;
}

---

10、成员指针

10.1、成员变量指针

Student s;
string* p = &s.m_name;//不是
Student s2;

（1）定义
成员变量类型 类名::*指针变量名；

string Student::*pname;
int Student::*page;

（2）初始化/赋值
指针变量名 = &类名::成员变量名

pname = &Student::m_name;
page = &Student::m_age;

（3）解引用
对象.*指针变量名
对象指针->*指针变量名

Student s, *p = &s;
s.*pname = “张飞”；
cout << p->*page << endl;

10.2、成员函数指针

（1）定义
成员函数返回类型 （类名::*指针变量名）（参数表）

void (Student::*plearn)(const string&) const;

（2）初始化/赋值
指针变量名 = &类名::成员函数名；

plearn = &Student::learn;

（3）解引用
（对象.*指针变量名）（实参表）；
（对象指针->*指针变量名）（实参表）；

(s.*plearn) ("C++");
(s->*plearn)("UNIX");

#include <iostream>
#include <cstring>
using namespace std;

class Student{
public:
	double m_weight;
	string m_name;
	int m_age;
	Student(const string& name, int age) : m_name(name), m_age(age){}
	void learn(const string& lesson) const{
		cout << "我在学" << lesson << endl;
	}
	static void hello(){
		cout << "你好！" << endl;
	}
};

int main(){
	string Student::*pname = &Student::m_name;
	void* pv;
	memcpy(&pv, &pname, 4);
	cout << pv << endl;
	int Student::*page = &Student::m_age;
	memcpy(&pv, &page, 4);
	cout << pv << endl;
	Student s("张飞", 25), *p = &s;
	cout << s.*pname << endl;
	cout << p->*page << endl;
	Student s2("赵云", 22);
	cout << s2.*pname << endl;

	void (Student::*plearn)(const string&) const = &Student::learn;
	(s.*plearn)("C++");
	(p->*plearn)("UNIX");
	void (*phello)() = &Student::hello;
	phello();
	return 0;
}