拷贝构造
拷贝构造函数是构造函数的一种，当利用已经存在的对象创建一个新对象时,类似于拷贝，就会调用新对象的拷贝构造函数进行初始化，拷贝构造函数的格式是固定的，接受一个const引用作为参数。
#include
using namespace std;
class Car {
int m_price;
public:
Car(int price = 0):m_price(price){
cout << "Car(int price = 0):m_price(price)" << endl;
}
Car(const Car &car):m_price(car.m_price){
cout << "Car(const Car &car):m_price(car.m_price)"
<< endl;
}
};
int main() {
Car car1; //调用构造函数
Car car2 = car1; //调用拷贝构造函数
return 0;
}
调用父类发拷贝构造函数，如下所示:
#include
using namespace std;
class Person {
protected:
int m_age;
public:
Person(int age = 0) :m_age(age) {
cout << "Person constructed function" << endl;
}
Person(const Person &person) :m_age(person.m_age) {
cout << "Person constructed copy function" << endl;
}
};
class Student : public Person {
int m_score;
public:
Student(int age = 0, int score = 0) :Person(age), m_score(score) {
cout << "Student constructed function" << endl;
}
Student(const Student &student) :Person(student), m_score(student.m_score) {
cout << "Student constructed copy function" << endl;
cout << this->m_age << endl;
}
};
int main() {
Student s1(10,100); //先调用父类的构造函数再调用自己的构造函数
Student s2 = s1;//先调用父类的拷贝构造函数再调用自己的拷贝构造函数
s2 = s1; //赋值操作，默认浅复制,不会调用拷贝构造函数
return 0;
}
一般来说对象之间的赋值是都是浅复制，浅拷贝，编译器默认提供的都是浅复制(浅拷贝)，即将对象所有的值赋值到另一个对象，这种清空下，如果对象类型有指针类型，浅拷贝只是拷贝指针存储的地址，指针指向的内容是不会拷贝的，这时就会出现多个指针指向同一个对象，对象释放的时候会多次释放出现问题，此时解决方案就是自定义拷贝构造函数，对指针指向的内容也进行拷贝，从而达到深拷贝的目的。下面举一个深拷贝的例子说明:
#include
using namespace std;
class Car {
int m_price;
char *m_name; //含有char *变量
public:
Car(int price = 0, const char *name = NULL) :m_price(price) {
if (name == NULL) return;
// 申请堆空间存储字符串内容
this->m_name = new char[strlen(name) + 1]{};
// 拷贝字符串内容到堆空间(string copy)
strcpy(this->m_name, name);
cout << "Car(int, const char *)" << endl;
}
Car(const Car &car) :m_price(car.m_price) {
if (car.m_name == NULL) return;
// 申请堆空间存储字符串内容
this->m_name = new char[strlen(car.m_name) + 1]{};
// 拷贝字符串内容到堆空间(string copy)
strcpy(this->m_name, car.m_name);
cout << "Car(const Car &car)" << endl;
}
~Car() {
if (this->m_name == NULL) return;
delete[] this->m_name;
this->m_name = NULL;
cout << "~Car()" << endl;
}
void display() {
cout << "price is " << this->m_price << ", name is " << this->m_name << endl;
}
};
int main() {
//构造char *的时候，构造函数需要拷贝字符串到内容，不然可能会出现堆空间成内存指向栈空间内存
char name[] = { 'b', 'm', 'w', '\0' };
Car *car = new Car(100, name);
car->display();
delete car;
Car car1(100, "bmw");
// 将car1的内存空间（8个字节）覆盖car2的内存空间（8个字节自定义拷贝构造函数会进行深拷贝）
Car car2 = car1;
return 0;
}
对象作为参数和返回值的时候，有些情况会调用拷贝构造函数，有些函数不会调用拷贝构造函数，不同编译器优化可能不一样。
#include
using namespace std;
class Car {
public:
int m_price;
Car(int price = 0) :m_price(price) {
cout << "Car(int) - " << this << " - " << this->m_price << endl;
}
Car(const Car &car) :m_price(car.m_price) {
cout << "Car(const Car &) - " << this << " - " << this->m_price << endl;
}
};
void test1(Car car) {
}
Car test2() {
Car car(10);
return car;
}
int main() {
Car car1(10);
test1(car1); //当对象作为函数参数的时候会调用拷贝构造函数，用引用就不会
Car car2 = test2(); //这里返回一；个临时对象，不同编译器优化可能不一样，我这里没有没有调用拷贝构造函数
Car car3;
car3 = test2();//这里返回一个临时对象，不同编译器优化可能不一样，我这里没有没有调用拷贝构造函数
return 0;
}
匿名对象
没有变量名，没有被指针指向的对象，用完后马上调用析构函数，参考如下:
#include
using namespace std;
class Person {
public:
int m_age;
Person(int age):m_age(age) {
cout << "Person() - " << this << endl;
}
Person(const Person &person) {
cout << "Person(const Person &person) - " << this << endl;
}
~Person() {
cout << "~Person() - " << this << endl;
}
void display() {
cout << "display()" << endl;
}
};
void test1(Person person) {
}
Person test2() {
// Person person;
return Person(5); //匿名对象
}
int main() {
Person p = test2();
cout << p.m_age << endl;
Person(10); //匿名对象
return 0;
}
在某些特定情况下，会隐式调用函数的单参数的构造函数，比如
Person p = 10; //隐式构造
我们可以加上关键字explicit来禁止函数的隐式构造。
Person(int age):m_age(age) {
cout << "Person() - " << this << endl;
}
默认构造函数
C++编译器在某些特定情况下，会给类自动生成无参的构造函数，比如。
- 成员变量在声明的同时进行了初始化。
- 有定义虚函数
- 虚继承了其它类
- 包含了对象类型的成员
- 父类有构造函数，编译器生成或自定义
通过以上规律可以看出，对象创建后，需要做一些额外操作时(内存操作，函数调用)编译器一般都会为其自动生成无参的构造函数。编译器是否生成了无参数的构造函数，通过断点查看反汇编函数调用过程。
友元
友元包括友元函数和友元类
- 如果将函数A(非成员函数)声明为类C的友元函数，那么函数A就能直接访问类C对象的所有成员，如果将类A声明为类C的友元类，那么类A的所有成员函数都能直接访问类C对象的所有成员
-友元破坏了面向对象的特性，但在某些频繁访问成员变量的地方可以提高性能。
#include
using namespace std;
class Point {
friend Point add(const Point &, const Point &);
friend class Math;
private:
int m_x;
int m_y;
public:
int getX() const { return this->m_x; };
int getY() const { return this->m_y; };
Point(int x, int y) :m_x(x), m_y(y) { }
};
class Math {
public:
Point add(const Point &point1, const Point &point2) {
return Point(point1.m_x + point2.m_x, point1.m_y + point2.m_y);
}
};
Point add(const Point &point1, const Point &point2) {
return Point(point1.m_x + point2.m_x, point1.m_y + point2.m_y);
}
int main() {
Point point1(10, 20);
Point point2(20, 30);
Point point = add(point1, point2);
cout << endl;
getchar();
return 0;
}
内部类
如果将类A定义在类C的内部，那么类A就是一个内部类(嵌套类)
- 支持public、protected、public、权限
- 成员函数可以直接访问其外部类对象的所有成员，反过来不行
- 成员函数可以直接不带类名、对象名访问其外部的static成员
- 不会影响外部类的内存布局
- 可以在外部类内部声明，在外部类外面进行定义
局部类
在一个函数内部定于的类，被称为局部类。它的作用域仅限于所在的函数内部，其所有的成员必须定义在类内部，不允许定义static成员变量，成员函数不能直接访问函数的局部变量，可以访问static成员变量。
#include
using namespace std;
int g_age = 20;
void test() {
int age = 10;
static int s_age = 30;
// 局部类
class Person {
public:
static void run() {
g_age = 30;
s_age = 40;
//age = 100; //内部类不允许访问函数局部变量
cout << "run()" << endl;
}
};
Person person;
Person::run();
}
int main() {
test();
getchar();
return 0;
}