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;
}