【C++】二、类和对象

一、面向过程和面向对象

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题；
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

C++是基于面向对象的，面向对象和面向过程混编，因为C++兼容C ；

二、类

1.C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。

2.类的定义

class className
{//类体，由成员变量和成员函数组成
};

类有两种定义方式：
a、 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理；

class Person
{
public:void showInfo(){}
public:char* _name;char* _sex;int _age;
};

b、类声明放在.h文件中，类定义放在.cpp文件中，要在.cpp函数前加类名

//.h文件中
class Person
{
public:void showInfo();
public:char* _name;char* _sex;int _age;
};//.cpp文件中
void Person::showInfo()
{}

3.类的访问限定符和封装

a、C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用;
(1). public修饰的成员在类外可以直接被访问
(2). protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
(3). 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
(4). 如果后面没有访问限定符，作用域就到 } 即类结束。
(5). class的默认访问权限为private，struct为public(因为struct要兼容C)

b、C++中struct和class的区别：
C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用 来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义 的类默认访问权限是private。注意：在继承和模板参数列表位置，struct和class也有区别。

c、封装
面向对象的三大特性：封装、继承、多态。
在类和对象阶段，主要是研究类的封装特性，那什么是封装呢？
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来 和对象进行交互。
封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用
户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日
常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

4.如何计算类的大小
a、类中只存储成员变量，成员函数放在公共的代码段；
b、空类或者只有成员函数的类大小时1byte，只是为了占位表示对象存在；

5.this指针

class Date
{
public:void Init(int year,int month,int day){year = _year;month = _month;day = _day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}
public:int _year;int _month;int _day;
};int main()
{Date d1;d1.Init(2023, 2, 4);d1.Print();return 0;
}

a、隐藏的this指针；
对象d1.Print();代码的意思有两层，第一层是去访问Print() 函数；第二层是编译器会处理将d1的地址传过去即：d1.Print(&d1);函数则有对应的形参接收即
void Print(Date* this)
{
cour<< this->_year << "-" << this->_month << "-" << this->_day << endl;
}

注：
(1)、调用成员函数时，不能显示传参给this；
(2)、定义成员函数时，也不能显示声明形参this；
(3)、在成员函数内部，可以显示使用this；

this存在哪里？
一般情况下存在于栈中，还有可能存在于寄存器中，主要看编译器；

三、类的6个默认成员函数

1.构造函数
概念：构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任
务并不是开空间创建对象，而是初始化对象。
a、函数名与类名相同。
b、无返回值。
c、对象实例化时编译器自动调用对应的构造函数。
d、构造函数可以重载。

class Date
{
public:Date(){_year = 0;_month = 1;_day = 1;}Date(int year, int month, int day){year = _year;month = _month;day = _day;}
public:int _year;int _month;int _day;
};

上边两个函数可以使用缺省函数合并成一个函数

    Date(int year=0, int month=1, int day=1){_year = year;_month = month;_day = day;}

e、如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

class Date
{
public:
private:int _year;int _month;int _day;
};int main()
{Date d1;return 0;
}

注：此时存在构造函数；
此时默认生成的构造函数，对于内置类型不做初始化处理，对于自定义类型会回去调用它的无参的默认构造函数进行初始化；如果没有默认构造函数就会报错；（所以需要有无参或者全缺省的构造函数）

f、无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

2.析构函数
与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
a、析构函数名是在类名前加上字符 ~；
b、无参数无返回值类型；
c、一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载；
d、对象生命周期结束时，C++编译系统系统自动调用析构函数；

class Stack
{
public:Stack(int capacity = 4){_a = (int*)malloc(sizeof(int)*capacity);if (_a == nullptr){cout << "malloc fail\n" << endl;exit(-1);}_top = 0;_capacity = capacity;}~Stack(){free(_a);_a = nullptr;_capacity = _top = 0;}
private:int* _a;size_t _top;size_t _capacity;
};int main()
{Stack s1;Stack s2;return 0;
}

注：默认生成的析构函数与构造函数类似，对于内置类型不处理，对于自定义类型，回去调用它的析构函数；

3.拷贝构造函数
只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
a、拷贝构造函数是构造函数的一个重载形式。
b、拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，
因为会引发无穷递归调用。

    Date(const Date& d){_year = d._year;_month = d._month;_day = d._day;}int main()
{Date d2(d1);
}

注：不引用引发递归的原因，调用拷贝构造，需要先传参，而传值传参是一份临时拷贝，又会调用拷贝构造函数；
Date前加const当=两边写反了，无操作时，可以检查出错误；

c、若未显式定义，编译器会生成默认的拷贝构造函数。（对内置类型进行浅拷贝，对自定义类型，调用它的拷贝构造函数） 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。但是如果开辟了一块空间的拷贝构造，在析构时就会出现错误，因为浅拷贝只是按字节序将地址原封不动的搬过去，两个对象指向同一块空间，在进行析构时会导致对同一块空间进行两次释放；

4.赋值运算符重载
函数名： operator操作符
返回类型：看操作符运算后返回值是什么
参数：操作符有几个操作数，他就有几个参数
a、运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其 返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

注：默认情况下C++不支持自定义类型对象使用运算符；
不能通过连接其他符号来创建新的操作符：比如operator@ ；
重载操作符必须有一个类类型参数；
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义；
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的 this；
. * 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现；

class Date
{
public:Date(int year = 0, int month = 1, int day = 1){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};//函数名： operator操作符
//返回类型：看操作符运算后返回值是什么
//参数：操作符有几个操作数，他就有几个参数
bool operator>(const Date& d1, const Date&d2)//c++中传参一般传引用，并且防止将引用的值改变加上const
{if (d1._year > d2._year){return true;}else if (d1._year > d2._year&&d1._month > d2._month){return true;}else if (d1._year > d2._year&&d1._month > d2._month&&d1._day > d2._day){return true;}else{return false;}
}int main()
{Date d1(2022, 1, 16);Date d2(2022, 1, 31);return 0;
}

此时重载操作符不可以使用，因为成员变量此时在类外不可以访问，解决办法有三种，将私有变成公有；在类内定义一个获取数据函数；友元函数解决；

class Date
{
public:Date(int year = 0, int month = 1, int day = 1){_year = year;_month = month;_day = day;}bool operator>(const Date& d1, const Date&d2){if (d1._year > d2._year){return true;}else if (d1._year > d2._year&&d1._month > d2._month){return true;}else if (d1._year > d2._year&&d1._month > d2._month&&d1._day > d2._day){return true;}else{return false;}}//private:int _year;int _month;int _day;
};

注：如果放在类内的话在调用时为 d1.operator(d2)会存在隐含的this指针，而>操作数应该只有两个，加上this指针后参数增多无法编译；改为下边的版本；

class Date
{
public:Date(int year = 0, int month = 1, int day = 1){_year = year;_month = month;_day = day;}bool operator>(const Date& d)//bool operator>(Date* const this, const Date& d){if (_year > d._year){return true;}else if (_year > d._year&&_month > d._month){return true;}else if (_year > d._year&&_month > d._month&&_day > d._day){return true;}else{return false;}}private:int _year;int _month;int _day;
};

此时在d1 > d2 调用时，会先看成员函数是否有重载函数，如果有会转化成d1.operator(d2);没有的话再去全局找重载函数；

b、赋值运算符的重载

class Date
{
public:Date(int year = 0, int month = 1, int day = 1){_year = year;_month = month;_day = day;}void operator=(const Date& d){_year = d._year;_month = d._month;_day = d._day;}private:int _year;int _month;int _day;
};

注：此时赋值运算符的重载有一些问题
赋值运算符的返回值类型应该是=左边的类型；因为存在做连等于的场景;
修改如下

    Date operator=(const Date& d){_year = d._year;_month = d._month;_day = d._day;return *this;}

注：但是此时Date是传值返回，返回时会多一次拷贝；
除了作用域如果*this还在就可以使用引用返回，所以在Date后边加&既可减少拷贝次数；
此时考虑会存在自身给自身赋值的情况，代码再加修改

    Date& operator=(const Date& d){if(this!=&d){_year = d._year;_month = d._month;_day = d._day;}return *this;}

特性：
a、参数类型：const T&，传递引用可以提高传参效率
b、返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
c、检测是否自己给自己赋值
d、返回*this ：要复合连续赋值的含义

Date d5 = d1

注：上边的一行代码是拷贝构造，不是赋值重载，因为赋值是在两个已经存在的对象之间进行的，而上边是一个已经存在的对象拷贝初始化一个马上创建实例化的对象；

四、再谈构造函数
1、初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

    Date(int year, int month, int day):_year(year),_month(month),_day(day){}

注:
a、每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)；
b、类中包含以下成员，必须放在初始化列表位置进行初始化：
引用成员变量；
const成员变量；
自定义类型成员(且该类没有默认构造函数时)；

class A
{
public:A(int a):_a(a){}
private:int _a;
};
class B
{
public:B(int a, int ref):_aobj(a),_ref(ref),_n(10){}
private:A _aobj;  // 没有默认构造函数int& _ref;  // 引用const int _n; // const 
};

c、尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

d、成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

class A
{
public:A(int a):_a1(a),_a2(_a1){}void Print() {cout<<_a1<<" "<<_a2<

注：答案为D。初始化顺序是按照声明的顺序进行的；

2、explicit关键字
构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

Date d2=2022;//隐式类型转换

注：此处本来是用2022 构造一个临时的对象Date(2022)，再用这个对象拷贝构造d2，但是C++编译器在连续的一个过程中，多个构造会被油画，合二为一。所以此处被优化为了一个构造；如果不想让此过程发生，在构造函数前加关键字explicit

    explicit Date(int year, int month, int day):_year(year),_month(month),_day(day){}

五、static成员
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化；

实现一个类，计算程序中创建出了多少个类对象。

class A
{
public:A() { ++_scount; }A(const A& t) { ++_scount; }~A() { --_scount; }static int GetACount() { return _scount; }
private:static int _scount;
};
int A::_scount = 0;
void TestA()
{cout << A::GetACount() << endl;A a1, a2;A a3(a1);cout << A::GetACount() << endl;
}

例：

class Sum
{
public:Sum(){_ret += _i;++_i;}int GetRet(){return _ret;}private:static int _i;static int _ret;
};int Sum::_i = 1;
int Sum::_ret = 0;class Solution 
{
public:int Sum_Solution(int n){Sum a[n];return Sum().GetRet() - (n + 1);}
};

注：
a、静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区；
b、静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明；
c、类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问；
d、静态成员函数没有隐藏的this指针，不能访问任何非静态成员；
e、静态成员也是类的成员，受public、protected、private 访问限定符的限制；

六、C++11 成员初始化的新语法

C++11支持非静态成员变量在声明是进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值；

class B
{
public:B(int b = 0):_b(b){}int _b;
};class A
{
public:void Print(){}private:int a = 10;B b = 20;int* p = (int *)malloc(4);//这里不是初始化，这里是给声明的成员变量缺省值static int n;              //静态变量不可以这样使用
};int A::n = 10;

七、友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元分为：友元函数和友元类

1、友元函数
注：
友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同

2、友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。友元关系是单向的，不具有交换性。
比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

友元关系不能传递 如果C是B的友元， B是A的友元，则不能说明C时A的友元。

友元关系不能继承，在继承位置再给大家详细介绍。

class Time
{friend class Date;   // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类
中的私有成员变量
public:Time(int hour = 0, int minute = 0, int second = 0): _hour(hour), _minute(minute), _second(second){}private:int _hour;int _minute;int _second;
};
class Date
{
public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}void SetTimeOfDate(int hour, int minute, int second){// 直接访问时间类私有的成员变量_t._hour = hour;_t._minute = minute;_t._second = second;}private:int _year;int _month;int _day;Time _t;
};

八、内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
特性：
1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系。

class A
{
private:static int k;int h;
public:class B // B天生就是A的友元，b可以访问a，a不能访问b{public:void foo(const A& a){cout << k << endl;//OKcout << a.h << endl;//OK}};
};
int A::k = 1;
int main()
{A::B b;b.foo(A());return 0;
}

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！