类和对象
- 如果说对象是楼房，那么实例化就是建造楼房，类表示的就是建造图纸；
对象的四大特征：
抽象：抽象出具体事物的普遍特征；比如将事物按照某些标准进行类型的划分；
封装：将数据和处理函数放在一起，提供一种功能；
继承：数据和处理函数的传承；
多态：表示同一个事物的多种形态；
类的定义和创建
一般使用class来定义类
class 类名{
成员变量
成员函数声明
};
*成员变量：对象内部的数据和状态，只能在类定义中声明，可以在成员函数中直接调用；
*成员函数：对对象的相关操作，可以在类的内部或者在外部实现；
::：用于域运算符用于表示函数的归属；
class限定符号：
public：表示访问限定符号，表示在类的范围之外是可以使用的；
private：表示私有，只能够在类的内部进行访问，如果在类的外部进行访问，就会出现私有类拒绝访问的情况；
protected：表示受保护的类，能够在类和继承的子类中进行访问；
*通常情况下，成员变量使用private或者protected，成员函数多使用public;
class Complex{
public:
//函数重载，如果调用没有参数找这个函数，如果有参数，
//找下面的函数,规范的成员变量初始化;
Complex():real(0),imag(0){
}
private:
float real;
float imag;
};
class与struct区别是：
- 默认的访问控制不同
-
struct是public -
class是private
-
struct可以使用花括号内的初始值列表{...}初始化，class不可以(C++98不可以，C++11可以)。
注意：
- C++的
struct可以有成员函数，而C不可以。 - C++的
struct可以使用访问控制关键字(publicprivateprotected)，而C不可以。
struct使用的一个举例
#include <cstdio.h>
//定义类成员变量
struct Complex{
float real;
float imag;
};
//定义函数声明
void print(Complex comp){
printf("%f+%fi\n",comp.real,comp.imag);
}
int main(){
Complex comp = {1,2};
print(comp);
}
运行结果是1.000000+2.000000i;
关于成员变量的初始化顺序
#include <iostream>
using namespace std;
class Member1{
public:
Member1(){
cout << "Member1 Init" << endl;
}
};
class Member2{
public:
Member2(){
cout << "Member2 Init" << endl;
}
};
class Member3{
public:
Member3(){
cout << "Member3 Init " << endl;
}
};
class Test{
public:
Test():m3(),m2(),m1(){};
//初始化的顺序只和private里面的成员的顺序有关；
private:
Member1 m1;
Member3 m3;
Member2 m2;
};
int main(){
Test test;
}
程序运行的结果为：
Member1 Init
Member3 Init
Member2 Init
*成员变量在使用初始化列表初始化时，与构造函数中初始化成员列表的顺序无关，只与定义成员变量的顺序有关;
在来看一个复数相加的例子
#include <cstdio.h>
class Complex{
//成员变量声明：
public:
void print();
Complex add(Complex other);
//这里是不能够将变量声明改为private的，如果改变就会出现：
//error: could not convert ‘{1, 2}’ from ‘<brace-enclosed
//initializer list>’ to ‘Complex’
float real;
float imag;
};
void Complex::print(){
printf("%f+%fi",real,imag);
}
Complex Complex::add(Complex other){
Complex res;
res.real = other.real + real;
res.imag = other.imag + imag;
return res;
}
int main(){
Complex comp1 = {1,2};
Complex comp2 = {2,3};
Complex res = comp1.add(comp2);
res.print();
comp2.add(comp1).print();
//print(comp);
}
*程序运行的结果是：
3.000000+5.000000i
3.000000+5.000000i
对象的创建
- 直接定义 -- 类作为类型定义变量 -- 栈上创建
类名 对象1;
类名 对象2 = 对象1;
类名 对象3(对象1);
#include <iostream>
using namespace std;
class CopyConstrutor{
public:
CopyConstrutor (){
cout << __func__ << "no pragrm"<< endl;
}
CopyConstrutor(CopyConstrutor& c){
cout << __func__ << endl;
}
//这个表示的是析构函数，用来处理主函数运行完成之后的资源回收；
~CopyConstrutor(){
cout << __func__ << endl;
}
};
int main(){
//对象创建的三种形式分别和上面相对应；
CopyConstrutor cc;
CopyConstrutor cc2 = cc;
CopyConstrutor cc3(cc2);
}
- 动态创建 -- 堆上创建
类名* 对象指针 = new 类名;
delete 对象指针;
Complex *pcomp4 = new Complex;
delete pcomp4;
*malloc和free的区别：
malloc是不会调用析构函数的，但是delete时回调用析构函数的，当对象离开作用域就会调用析构函数;
在C++中除了特殊的情况，很少直接使用malloc()/free()申请释放内存，取尔代之的是new/delete，new和delete在申请内存和释放内存过程中时做的工作要比malloc和free更多；
this指针
this指针的特点是：
*this指针是类的内部；
*this指针是类的一个自动生成、自动隐藏的私有成员；
*每个类有且只有一个this指针；
*当一个对象被创建时，this指针就存放指向对象数据的首地址；
*this指针不是对象本身的一部分，不会影响sizeof(对象)的结果；
private:
float real;
float imag;
cout << sizeof(Complex) << endl;
//得到的结果是：8；
方法
析构函数与构造函数
*析构函数必须和类名称相同
*构造函数的语法
类名(参数){
函数体；
}
class Test {
public:
Test(){
cout << "Test no param" << endl;
}
Test()
};
Test ret(){
Test t;
return t;
}
*构造函数时，需要注意的是：
1、构造函数在对象被创建时自动执行；
2、构造函数的函数名与类名相同；
3、构造函数没有返回值类型，也没有返回值；
4、可以创造多个构造函数；
**调用时机
1、构造函数是对象直接定义创建--构造函数不能被显式调用；
2、new可以动态创建；
*关于默认构造函数
在类中没有显式的定义构造函数，编译器就会自动为该类型生成默认函数；
*构造函数的三个作用
1、给创建的对象建立一个标识符；
2、为对象数据成员开辟内存空间；
3、完成对象数据成员的初始化；
*初始化列表
*语法
类名(参数)：成员变量(参数){
函数体
}
Complex():real(0)，imag(0){
}
Complex(float real,float imag):real(real),imag(imag){
}
Complex add(Complex other){
Complex res;
res.real = other.real + real;
res.imag = other.imag + imag;
return res;
}
*作用
初始化非静态成员变量
*说明
从概念来说，构造函数的执行可以分为两个阶段，初始化阶段，计算阶段；初始化阶段先于计算阶段。
*初始化列表的使用
1、常量成员，因为常量只能在初始化，不能够进行赋值，所以必须放在初始化列表里面；
2、引用类型，引用类型必须在定义的时候初始化，所以不能够重新赋值，所以也许要写在初始化列表里面。
3、没有默认构造函数的类类型，因为使用初始化列表可以不必调用默认构造函数来初始化。
#include <iostream>
using std::cout;
using std::endl;
class Member1{
public:
Member1(){
cout << "Member1 Init" <<endl;
}
};
class Member2{
public:
Member2(){
cout << "Member2 Init" <<endl;
}
};
class Member3{
public:
Member3(){
cout << "Member3 Init" <<endl;
}
};
class Test{
public:
Test():m3(),m2(),m1(){};
private:
Member1 m1;
Member2 m2;
Member3 m3;
};
int main(){
Test test;
}
程序执行的结果是：
Member1 Init
Member2 Init
Member3 Init
*也就是说成员变量在使用初始化列表初始化时，与构造函数中初始化列表的顺序无关，只与成员变量的顺序有关；
析构函数
*语法：
～类名(){
函数体
}
1、结构函数的函数名必须和类名相同；
2、析构函数的函数名前面必须有一个~；
3、析构函数没有参数；
4、析构函数没有返回值以及返回值类型；
5、在一个类中只能有一个析构函数；
*析构函数的调用时机
1、当对象离开作用域时；
2、党执行delete时；
*默认的析构函数
当类中没有显式的定义析构函数时，编译器会自动为该类型生成默认的析构函数；
*析构函数是用来释放对象所占有的资源的；
class Test {
Test(){
cout << "Test no param" << endl;
}
//析构函数
~Test(){
cout << "~Test()" << endl;
}
};
引用
*语法
声明：const 类名& 对象名/类名&对象名
Test(Test& t){
cout << "Test copy" << endl;
}
void printf(Test* t){
}
使用：引用与对象变量、基本类型变量一样
*引用的使用
*函数参数列表
*成员变量 -- 对象初始化时，必须显式初始化的变量
*为何使用引用
*避免对象复制
*避免传递空指针
*使用会比较方便
引用和指针的区别：
1、指针指向一块内存，它的内容是所指向内存的地址；但是引用是某块内存区域的别名；
2、引用只能在被定义时初始化一次，并且之后不允许改变；但是指针的值使可以改变的；
3、引用是不能够为空的，但是指针是可以为空的；
4、引用使用时，是不需要解引用*的，但是指针需要解引用；
5、sizeof 引用得到的是所指向的变量/对象的大小，而sizeof 指针得到的是指针本身的大?。?br>
6、指针的自增运算符表示的含义是地址的自增，但是引用的自增得到的是引用的值的自增；
拷贝构造函数
*语法：
类名(类名& 形参){
函数体；
}
类名(const 类名& 形参){
函数体；
}
拷贝构造函数的调用时机：
1、一个对象作为函数参数，以值传递的方式传入函数体；
2、一个对象作为函数返回值，以值传递的方式从函数返回；
3、一个对象用于给另一个对象进行初始化(赋值初始化)
*需要注意的是：
g++编译器对于拷贝构造函数自动进行优化操作，默认是不止行构造函数的，需要在编译命令添加禁止
-fno-elide-constructors;
所以不建议返回局部对象；
#include <iostream>
using namespace std;
class Test{
public:
Test(){
cout << "Test no param" << endl;
}
~Test(){
cout << "~Test()" << endl;
}
Test(Test& t){
cout << "Test copy" << endl;
}
};
void print(Test* t){}
#ifndef REFER_TEST
void print(Test t){}
#else
void print(Test& t){ }
#endif
Test ret(){
Test t;
return t;
}
int main(){
Test t;
//print(t);
//print(&t);
ret();
cout << "test" << endl;
}
默认拷贝函数
*本质：内存拷贝
*作用：复制一个已经存在的对象
赋值运算符重载函数
*语法
类名& operater = (类名& 形参)
类名& operator = (const 类名& 形参)
类名& operator = (形参)
