C++ | 【02】基础概念

曾经终败给现在 2022-10-05 12:50 208阅读 0赞

### 文章目录 ###

*   *   *   *  一、面向对象案例
             *   *  1、长方形案例
                 *  2、点和园的关系
             *  二、面向对象的构造和析构
             *   *  2.1 初始化和清理
                 *   *  2.1.1 构造函数
                     *  2.1.2 析构函数
                 *  3、匿名对象
                 *  4、隐式类型转换
                 *  5、深拷贝和浅拷贝
                 *   *  5.1 浅拷贝
                     *  5.2 深拷贝
                 *  6、多个对象构造和析构
                 *   *  6.1 初始化列表
                 *  7、explicit关键字
                 *  8、动态对象创建
                 *   *  8.1 C++中尽量不是用动态申请空间
                     *  8.2 new【堆】
                 *  8、静态成员
                 *   *  8.1 静态成员变量
                     *  8.2 静态成员函数
                     *  8.3 静态成员实现单例模式
                 *  9、对象模型
                 *   *  9.1 成员变量和函数的存储
                     *  9.2 this指针
                     *  9.3 空指针访问成员函数
                     *  9.4 常函数与常对象
                 *  10、友元
             *  三、多种运算符
             *   *  1、加号运算符重载
                 *  2、左移运算符重载
                 *  3、前置后置递增运算符重载
                 *  4、智能指针
                 *  5、\[\]运算符
                 *  6、==运算符
                 *  7、()运算符
                 *  8、总结

#### 一、面向对象案例 ####

##### 1、长方形案例 #####

#include<iostream>
    using namespace std;
    
    
    /* * 计算出面积和体积用全局函数和成员函数判断俩个立方体是否相等 */
    class Cube
    { 
    public:
    	// 长
    	void setX(int x)
    	{ 
    		C_x = x;
    	}
    
    	int getX()
    	{ 
    		return C_x;
    	}
    	
    	// 宽
    	void setY(int y)
    	{ 
    		C_y = y;
    	}
    
    	int getY()
    	{ 
    		return C_y;
    	}
    
    	// 高
    	void setz(int z)
    	{ 
    		C_z = z;
    	}
    
    	int getZ()
    	{ 
    		return C_z;
    	}
    
    	/* * 计算面积 */
    	int getS()
    	{ 
    		return 2 * (C_x*C_y + C_x*C_z + C_y*C_z);
    	}
    
    	/* * 计算体积 */
    	int getV()
    	{ 
    		return C_x *C_y *C_z;
    	}
    
    	/* * 长方形对比 */
    	bool CompareCube(Cube &c)
    	{ 
    		bool isEqual = C_x == c.getX() && C_y == c.getY() && C_z == c.getZ();
    
    		return isEqual;
    	}
    
    private:
    	int C_x;
    	int C_y;
    	int C_z;
    };
    
    /* 比较函数 */
    bool CompareCube(Cube &c1, Cube &c2)
    { 
    	bool isEqual = c1.getX() == c2.getX() && c1.getY() == c2.getY() && c1.getZ() == c2.getZ();
    
    	return isEqual;
    }
    
    void test()
    { 
    	Cube c1;
    	c1.setX(10);
    	c1.setY(10);
    	c1.setz(20);
    	int s = c1.getS();
    	int v = c1.getV();
    
    	Cube c2;
    	c2.setX(10);
    	c2.setY(10);
    	c2.setz(20);
    	int s_ = c2.getS();
    	int v_ = c2.getV();
    	
    	bool isEqual = CompareCube(c1, c2);
    	if (isEqual == 1)
    	{ 
    		cout << "全局函数判断：俩个长方形相等" << endl;
    	}
    	else
    	{ 
    		cout << "全局函数判断：俩个长方形不相等" << endl;
    	}
    
    	bool isEqual_ = c1.CompareCube(c2);
    	if (isEqual_ == 1)
    	{ 
    		cout << "成员函数判断：俩个长方形相等" << endl;
    	}
    	else
    	{ 
    		cout << "成员函数判断：俩个长方形不相等" << endl;
    	}
    
    	cout << "S:" << s << "\nV:" << v << endl;
    }
    
    
    int main()
    { 
    	test();
    
    	system("pause");
    	return 0;
    }

##### 2、点和园的关系 #####

#include<iostream>
    using namespace std;
    
    
    /* 计算点是否在圆上 圆的属性：圆心(x,y)，半径 点：(x, y) */
    
    class Point
    { 
    public:
    	// 设置x
    	void setX(int x)
    	{ 
    		C_x = x;
    	}
    
    	int getX()
    	{ 
    		return C_x;
    	}
    
    	// 设置y
    	void setY(int y)
    	{ 
    		C_y = y;
    	}
    
    	int getY()
    	{ 
    		return C_y;
    	}
    
    private:
    	int C_x;
    	int C_y;
    };
    
    class Circle
    { 
    public:
    
    
    	// 设置r
    	void setR(int r)
    	{ 
    		C_r = r;
    	}
    
    	int getR()
    	{ 
    		return C_r;
    	}
    
    	// 设置圆心
    	void setO(Point o)
    	{ 
    		O = o;
    	}
    
    	Point getO()
    	{ 
    		return O;
    	}
    
    private:
    	Point O;
    	int C_r;
    };
    
    
    void isequal(Circle &c, Point &p)
    { 
    	int x_ = c.getO().getX() - p.getX();
    	int y_ = c.getO().getY() - p.getY();
    
    	int result = x_*x_ + y_*y_;
    	if (c.getR()*c.getR() < result)
    	{ 
    		cout << "该点在圆外" << endl;
    	}
    	else if (c.getR()*c.getR() > result)
    	{ 
    		cout << "该点在圆内" << endl;
    	}
    	else
    	{ 
    		cout << "该点在圆内上" << endl;
    	}
    }
    
    void test()
    { 
    	// 创建圆
    	Circle c;
    	c.setR(5);
    	Point co;
    	co.setX(3);
    	co.setY(4);
    	c.setO(co);
    
    	// 创建点
    	Point p;
    	p.setX(2);
    	p.setY(3);
    
    	isequal(c, p);
    }
    
    int main()
    { 
    	test();
    	system("pause");
    	return 0;
    }

#### 二、面向对象的构造和析构 ####

##### 2.1 初始化和清理 #####

> 当创建一个对象的时候，应该需要有一个初始化状态，而当对象销毁之前应该销毁掉自己所创建的数据。  
> 因此有了初始化时的`构造函数`和结束时的`析构函数`。并且在初始化的时候还提供了`拷贝构造函数`。

###### 2.1.1 构造函数 ######

>  *  `函数名`与类名相同；
>  *  没有`返回值`；
>  *  不能有`void`；
>  *  `参数`可以有。

>  *  当手动添加了有参构造函数，系统不会给我们提供默认的构造函数；
>  *  系统会默认提供拷贝构造函数，进行简单的值拷贝；
>  *  若手动提供拷贝构造，则系统就不会提供其他构造。

**分类**：

>  *  参数：
>     
>      *  无参；
>      *  有参；
>  *  类型：
>     
>      *  普通
>      *  拷贝。

> **拷贝**：【系统会默认提供】  
> 函数的参数传入一个`类`并且用`const`修饰。  
> 若使用`值传递`，则会在参数中还会增加`内存开销`，会执行一次创建对象。  
> 三种方式：
> 
>  *  用`创建好的对象`来初始化`新的对象`；
>  *  以`值传递`的方式给函数`参数传值`；
>  *  以`值方式`返回局部对象。

> **注意**：  
> 调用默认的构造函数后面`不需要加括号`，否则会被当成函数声明。

###### 2.1.2 析构函数 ######

>  *  函数名和类名相同，但需要在前面加上`~`；
>  *  没有`返回值`；
>  *  不能有`void`；
>  *  不能有`参数`；
>  *  不能`重载`。

> 需要注意`生命周期`的问题，在主函数中，对象没有被销毁，所以析构函数不会被执行。

>  *  当提供了析构函数，

##### 3、匿名对象 #####

> 直接使用`类名`若有参数则加括号加入参数例如`Circle(10);`

>  *  若编译器发现该对象是匿名对象，则在该行结束后就释放这个对象。
>  *  不能用拷贝函数来不初始化匿名函数，编译器会识别为对象声明；

> 对象创建的多种方式；
> 
>  *  `Circle c1 = Circle;`
>  *  `Circle c1;`
>  *  `Cirle;`

##### 4、隐式类型转换 #####

*  `Circle c1 = 100` ⇒ `Circle c1 = Circle c2(100)`；

##### 5、深拷贝和浅拷贝 #####

###### 5.1 浅拷贝 ######

>  *  浅拷贝【值拷贝】是将`指向原来的地址`，如果运用到指针中，在释放内存的时候，会遇到`多次释放`的冲突，导致错误。
>  *  若在类中使用拷贝，则需要`重写拷贝函数`，来避开指向同一个堆区，在程序结束释放空间是，避免多次释放造成的异常。

###### 5.2 深拷贝 ######

> 若有使用到`堆区`的空间，则在`拷贝`的过程中，需要在`另外开辟空间`，来避免释放的异常。

##### 6、多个对象构造和析构 #####

###### 6.1 初始化列表 ######

>  *  初始化属性；
>  *  `构造函数(参数): 属性(参数), 属性(参数)……`：参数可以是形参也阔以是实参

##### 7、explicit关键字 #####

>  *  防止隐式类型转换。
>  *  由于使用隐式转换的`用途不明确` 。

##### 8、动态对象创建 #####

###### 8.1 C++中尽量不是用动态申请空间 ######

>  *  在使用前必须确定对象的长度；
>  *  malloc返回的指针必须强转；
>  *  申请空间可能失败；
>  *  使用对象前还必须初始化，用户可能忘记调用。

> 因此，在C++中使用`new`来代替

###### 8.2 new【堆】 ######

> C+ +中解决动态内存分配的方案是把`创建一个对象`所需要的操作都结合在一个称为`new的运算符`里。当用new创建一个对象时,它就在堆里为对象`分配内存`并`调用构造函数完成初始化`。

>  *  New能确定在构造函数初始化之前内存分配是成功的；
>  *  内带有`长度计算`、`类型转换`、`安全检查`。
>  *  使用`delete`释放堆空间
>  *  当使用`void*`来接收会出现无法释放的问题；
>  *  可以用来`开辟数组`，会默认调用构造，所以必须提供构造函数；
>     
>      *  由于new内部会记录数组的个数，所以释放的时候要加上`[]`；
>  *  若释放数组时，需要在`delete`后加上`[]`；
>  *  在栈区创建数组，可以指定构造参数。

##### 8、静态成员 #####

###### 8.1 静态成员变量 ######

>  *  在定义变量时前面加上`static`；
>  *  编译阶段分配内存
>  *  所有对象能够`共享数据`；
>  *  一般在`类内声明`，`类外初始化`，防止通过`类名直接访问`属性没有调用构造函数；
>  *  若私有属性，也可以通过类名在外部初始化`数据类型 类名::属性=赋值`。

###### 8.2 静态成员函数 ######

>  *  由于`数据共享`（多个对象共享一个），所以`不能访问普通的成员属性`，无法区分多个对象中的变量。

###### 8.3 静态成员实现单例模式 ######

> 是一种常见的`软件设计模式`。可以保证系统中`一个类只有一个实例`且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。

>  *  为了让类只有`一个实例`，实例`不需要自己释放`。
>  *  将`默认构造`和`拷贝构造私有化`；
>  *  内部维护`一个对象指针`；
>  *  私有化`唯一指针`；
>  *  对外提供`getinstance`来访问指针；
>  *  保证类中只能实例化`唯一一个对象`。

#include<iostream>
    using namespace std;
    
    class  Printer
    { 
    public:
    
    	// 开放接口
    	static Printer *getInstance()
    	{ 
    		return singlePrinter;
    	}
    
    	// 测试接口
    	void testPrinter()
    	{ 
    		cout << "我是打印机" << ++num << endl;
    	}
    
    private:
    	int num;
    	// 静态成员
    	static Printer* singlePrinter;
    
    	// 构造函数初始化
    	Printer()
    	{ 
    		num = 0;
    	};
    	// 拷贝构造函数
    	Printer(const Printer &p);
    
    };
    
    // 类外声明
    Printer *Printer::singlePrinter = new Printer;
    
    
    int main()
    { 
    	// 实例化对象
    	Printer *printer = Printer::getInstance();
    	
    	printer->testPrinter();
    	printer->testPrinter();
    
    	system("pause");
    	return 0;
    }

##### 9、对象模型 #####

###### 9.1 成员变量和函数的存储 ######

> C++中实现了封装。实际上`数据`和`函数`是分开存储的。

>  *  所有空类大小为`1`，每个实例的对象，都有`独一无二`的地址，`char`维护这个地址。
>  *  只有`非静态成员变量`，才属于`对象`。

###### 9.2 this指针 ######

**从前一节可知，成员函数共享同一个，但在不同对象中改如何区分？**

> 所以引出了使用`this`在内部做区分。

**this工作原理**

>  *  `this`指针指向被调用的成员函数所属的对象【指向本对象的指针】，编译器会默认添加。
>  *  是隐含在`对象成员函数`内的一个指针。当对象被创建后，它的每一个成员函数都含有一个系统自动生成的`隐含指针this`用来保存这个对象的地址。
>  *  不会影响`sizeof`的结果。
>  *  静态成员函数内部没有`this指针`，静态成员函数不能操作`非静态成员变量`。
>  *  【解决命名冲突】：若参数与成员变量同名时，没有使用this来指向该对象的成员变量时，编译器会混淆变量，导致无法区分该变量。
>  *  `*this`：阔以返回当前对象

#include<iostream>
    using namespace std;
    
    
    
    class  testClass
    { 
    public:
    	// 第一点【解决命名冲突】：若参数与成员变量同名时，没有使用this来指向该对象的成员变量时，编译器会混淆变量，
    	// 导致无法区分该变量。
    	testClass(int num)
    	{ 
    		this->num = num;
    	}
    	
    	int getNum()
    	{ 
    		return num;
    	}
    
    
    	// testClass add_(testClass &t)返回数值
    	testClass& add_(testClass &t)// 返回引用
    	{ 
    		this->num += t.num;
    
    		return *this;// 返回该对象
    	}
    
    
    private:
    	int num;
    };
    
    
    int main()
    { 
    	testClass t(20);
    
    	int a = t.getNum();
    
    	cout << "数值为：" << a << endl;
    
    	system("pause");
    	return 0;
    }

**数组案例**  
`ArrayList.h`

#pragma once
    #include <iostream>
    using namespace std;
    
    /*@ 创建一个数组类 */
    class  Array
    { 
    public:
    	/*@ 构造函数 */
    	Array();
    	/*@ 有参构造 */
    	Array(int capacity);
    	/*@ 拷贝构造 */
    	Array(const Array &array);
    
    	void insertVal(int val);
    
    	int getData(int index);
    
    	void modifyData(int index, int val);
    
    	/*@ 析构函数 */
    	~Array();
    
    private:
    	int l_capacity;	// 容量
    	int l_size;	// 存储个数
    	int *l_List;	// 存储数据
    };

`ArrayList.cpp`

#include "ArrayList.h"
    
    /*@ 构造函数 */
    Array::Array(){ 
    	// 初始化数组
    	l_capacity = 100;
    	l_size = 0;
    	l_List = new int[l_capacity];
    }
    
    /*@ 有参构造 */
    Array::Array(int capacity){ 
    	l_capacity = capacity;
    	l_size = 0;
    	l_List = new int[l_capacity];
    }
    
    /*@ 拷贝构造 */
    Array::Array(const Array &array){ 
    	this->l_capacity = array.l_capacity;
    	this->l_size = array.l_size;
    	this->l_List = new int[array.l_capacity];
    	for (int i = 0; i < array.l_size; ++i){ 
    		this->l_List[i] = array.l_List[i];
    	}
    }
    
    /*@ 插入数据 */
    void Array::insertVal(int val){ 
    	this->l_List[this->l_size] = val;
    	this->l_size++;
    }
    
    /*@ 根据索引获取数据 */
    int Array::getData(int index){ 
    	return this->l_List[index];
    }
    
    /*@ 根据索引修改数据 */
    void Array::modifyData(int index, int val){ 
    	this->l_List[index] = val;
    }
    
    /*@ 析构函数 */
    Array::~Array(){ 
    	if (this->l_List != NULL){ 
    		delete[] l_List;
    		l_List = NULL;
    	}
    }

`main.cpp`

#include<iostream>
    #include "ArrayList.h"
    using namespace std;
    
    
    void test01(){ 
    	Array L(100);
    	L.insertVal(13);
    	int dat = L.getData(0);
    	cout << "数值1为：" << dat << endl;
    	L.modifyData(0, 1);
    	dat = L.getData(0);
    	cout << "数值2为：" << dat << endl;
    }
    
    int main(){ 
    	test01();
    
    	system("pause");
    	return 0;
    }

###### 9.3 空指针访问成员函数 ######

>  *  若该成员函数中没有使用到该对象的属性，编译器不会报错。若使用到，则程序会挂掉；
>  *  故需要在成员函数中添加`判断this是否为空`。`if(this == NULL) return`。

###### 9.4 常函数与常对象 ######

**常函数**

>  *  不允许修改指针指向的值，修饰的是this指针；
>  *  在函数名()后加上`const`；
>  *  若在常函数中也要修改变量，则需要在该变量前添加`mutable`。

**常对象**

>  *  在创建对象前面加上`const`；
>  *  只能调用常函数。

##### 10、友元 #####

**全局函数做友元函数**

> 由于全局函数中访问不到私有属性，所以在类的下面声明全局函数并且在前面加上`friend`关键字。

**友元类**

>  *  `friend class 类名`；
>  *  友元是`单向`的，A是B的朋友，但B不是A的朋友，`不能被继承`；

**成员函数做友元函数**

> `friend void 作用域::函数名`

#### 三、多种运算符 ####

##### 1、加号运算符重载 #####

>  *  编译器提供成员函数相加：`p1.operate+(p2)` ⇒ `p1+p1`即可实现俩个对象之间变量的相加。

类名 operate+(类名&变量名)

>  *  提供全局函数：`operate+(p1, p2)` ⇒ `p1+p1`即可实现俩个对象之间变量的相加。

类名 operate+(类名&变量名, 类名&变量名)

>  *  若要实现则需要重写该方法。`类名 operate+(参数)`；
>  *  可重载。

##### 2、左移运算符重载 #####

>  *  必须写成全局函数；
>  *  能对自定义数据类型进行输出。
>  *  可多次重载，第一个参数是`ostream &cout`

ostream operate<<(ostream&cout, 自定义参数)
    { 
    	自定义内容;
    	return cout;
    }

##### 3、前置后置递增运算符重载 #####

**前置++**

> 先++，在返回自身

**后置++**

>  *  需要在成员函数内返回一个`临时的变量`，在对变量进行`++操作`。
>  *  需要在参数加上`int`与`前置++`进行区分。

**择优**

> 在日常使用中，多使用`前置++`会省略部分开销。

##### 4、智能指针 #####

> 创建一个智能指针类，用来对类的管理`释放`。

#include<iostream>
    using namespace std;
    
    
    class Person
    { 
    public:
    	Person(int age){ 
    		this->age = age;
    	}
    
    	void showInfo(){ 
    		cout << "年龄为：" << age << endl;
    	}
    
    	~Person(){ 
    		cout << "释放" << endl;
    	}
    
    private:
    	int age;
    };
    
    
    /*@ 智能指针，用于管理类的释放 */
    class SmartPointer
    { 
    public:
    	SmartPointer(Person *person);
    
    	/*@ 重写指针操作运算符 */ 
    	Person * operator->(){ 
    		return this->person;
    	}
    
    	/*@ 重写*操作运算符 */
    	Person &operator*(){ 
    		return *this->person;
    	}
    
    	~SmartPointer();
    
    private:
    	Person *person;
    };
    
    SmartPointer::SmartPointer(Person *person)
    { 
    	this->person = person;
    }
    
    SmartPointer::~SmartPointer()
    { 
    	if (this->person != NULL){ 
    		delete this->person;
    		this->person = NULL;
    	}
    }
    
    void test(){ 
    	//Person p1(20);
    	//p1.showInfo();
    	SmartPointer p(new Person(20));
    	p->showInfo();
    	(*p).showInfo();
    }
    
    int main(){ 
    
    	test();
    
    	system("pause");
    	return 0;
    }

##### 5、\[\]运算符 #####

int &operator(int index){ 
    	return array[index];
    }

##### 6、==运算符 #####

bool operator==(){ 
    
    }

##### 7、()运算符 #####

bool operator()(参数){ 
    
    }

>  *  一般不重载`&&`和`||`运算符。

##### 8、总结 #####

>  *  `=，[]，()和->`操作符只能通过`成员函数`进行重载；
>  *  `<<和>>`只能通过`全局函数配合友元函数`进行重载；
>  *  不要重载`&&和||`操作符,因为无法实现短路规则。