面向对象
C语言是面向过程的语言,关注的是求解问题的步骤,通过函数调用逐步解决问题;而C++是面向对象的,关注的是对象,将一件事情拆分为不同的对象,靠对象之间的交互解决问题.
类的引入
C语言的结构体只能定义变量,而C++中的结构体不仅可以定义变量,还可以定义函数
typedef int DataType;
struct Stack
{
void Init(size_t capacity)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (nullptr == _array)
{
perror("malloc申请空间失败");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(const DataType& data)
{
// 扩容
_array[_size] = data;
++_size;
}
DataType Top()
{
return _array[_size - 1];
}
void Destroy()
{
if (_array)
{
free(_array);
_array = nullptr;
_capacity = 0;
_size = 0;
}
}
DataType* _array;
size_t _capacity;
size_t _size;
};
而这样的结构体,在C++中就被称为”类”(class).定义一个类和struct类似,采用class关键字进行定义
class 类名
{
类体:成员变量&成员函数
};
类的定义有两种方式:
1.声明和定义全部放在类体中.
2.声明放在.h文件,定义放在.c


在工程中,第二种方法更为常用.此外,定义的成员变量变量名也会有一些约定成俗的规则:一般统一规定类的成员变量会加一个前缀作为区分,一般选_作为前缀.
类的访问与封装
访问限定符
C++将类的定义和属性相结合,这样可以使类的属性更加完善,并通过访问权限选择性地将接口提供给外部用户使用.

- public修饰的成员在类外可以直接被访问
- protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
- 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
- 如果后面没有访问限定符,作用域就到}即类结束。
- class的默认访问权限为private,struct为public(因为struct要兼容C)
class Student
{
private://一般情况下成员变量都是比较隐私的,都会定义成private/protect
char _name[10];
int _age;
int _id;
public://还会定义一些公有的方法;
void showInfo()
{
cout << _name << endl;
cout << _age << endl;
cout << _id << endl;
}
int GetAge()
{
return _age;
}
};
private/proctect私有指的是:在类外面无法进行访问,可以看到只能访问public的内容.

假设我们通过类封装了一个栈,我实际上并不希望你直接对我的成员变量进行使用(比如栈数组),而是通过我提供的接口进行入栈出栈等操作.这就是限定符意义所在.
class Stack
{
private:
int*_a;//栈数组
int top;
int capacity;
public:
void Init();
void Push();
void Pop();
void Destroy();
}
封装
面向对象的三大特征为:封装,继承,多态.
封装指将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互,本质上是一种管理和保护.上面的栈的实现就实现了这两点。
面向对象更加关注的是类与类之间的关系,它并不在乎你是如何实现的,它只在乎你能实现功能。而封装能够更好的帮助你管理代码。工程中要求低耦合,高内聚,这样工程项目才易于维护和拓展。
高内聚指:和我有关系的东西都全部放到一起;
低耦合指:类与类之间的关系越少越好,尽量不要出现互相影响的情况。
如果没有封装,所有东西都在一起,谁想进行访问都能进行。
类的作用域
类定义了一个新的作用域,类的所有成员都在类的作用域中。在类体外定义成员时,需要使用 :: 作用域操作符指明成员属于哪个类域。
class Person
{
public:
void PrintPersonInfo();
private:
char _name[20];
char _gender[3];
int _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
cout << _name << " "<< _gender << " " << _age << endl;
}
类的实例化
首先我们先确定一个问题:声明和定义的区别。
声明可以认为是一种承诺,但是还没有落实;而定义就是把承诺的事情落实了。如果只声明但是不定义就会报错。
class Stack
{
private:
int*_a;
int top;
int capacity;
public:
void Init();
void Push();
void Pop();
void Destroy();
};//这里所做的都是声明,变量的声明是在告诉系统我的这个类里要定义这些东西,但是并没有具体开空间;而函数的声明指我告诉系统了函数名,返回值和参数,但是具体的实现并没有落地
类是对对象进行描述的,是一个模型,限定了类有哪些成员。定义出一个类并没有分配实际的内存空间来存储它;现在我想定义一个栈,那么我就要用我定义的类创建一个对象,这个过程就叫类的实例化。一个类可以实例化出多个对象,实例化出的对象占用实际的物理空间,存储类成员变量.
int main()
{
Stack s1;
cout << sizeof(s1) << endl;//会输出什么?--12
return 0;
}
如果按结构体来说,它只存储了3个成员变量,那么最终的结果应该是12字节,但是如果把函数指针也算上,那就是28字节;最终输出的结果是12.说明:类实例化的对象中只存储成员变量,不存储成员函数.那为什么要这样呢?一个类可以实例化出多个对象,每个对象实例化出的成员变量都不同,但是成员函数是同一个,如果实例化存储了成员函数就会造成空间的浪费,成员函数只需要放到一个大家都能看到的地方就可以.

但是需要特别注意结构体的内存对齐问题,没有成员变量的类大小是1.
class A1 {
public:
void f1(){}
private:
int _a;
};//4
// 类中仅有成员函数
class A2 {
public:
void f2() {}
};//1
// 类中什么都没有---空类
class A3
{};//1
给没有成员变量的类开一个空间是为了占位,表示存在,否则:
int main()
{
A3 a;
A3 aa;//不开空间无法和a区分.
A3* pa=&a;//不开空间没办法取地址
return 0;
}
this指针
class Date
{
private:
int _year;
int _month;
int _day;
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
};
int main()
{
Date d1,d2;
d1.Init(2025, 8, 12);
d1.Print();
d2.Init(2022, 1, 12);
d2.Print();
}
打印结果与我们预想的一样,2025-8-12,2022-1-12,但是哪里有点不对?Date类中有 Init 与 Print 两个成员函数,函数体中没有关于不同对象的区分,那当d1调用 Init和Print 函数时,该函数是如何知道应该设置d1对象,而不是设置d2对象呢?
实际上,成员函数的参数除了我们设定的参数外,C++还引入了一个隐含的this指针,指向当前对象.
//我们定义的函数:
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
在经过编译器处理后会变成这样:
void Print(Date*this)
{
cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
}
void Init(Date*this,int year, int month, int day)
{
this->_year = year;
this->_month = month;
this->_day = day;
}
调用的时候会再次被处理为d1.Print(&d1),d1.Init(&d1,2025,8,12);这样就区分开了.
我们现在知道了this指针,那么又会引出其他一些问题:
1.this指针是存在哪的?
栈,this指针是函数的形参,函数参数也是函数栈帧的一部分(vs存储在ecx寄存器下)
2.this指针可以为空吗?
class A
{
public:
void Print()
{
cout << "Print()" << endl;
}
void Show()
{
cout << _a << endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->Print();
p->Show();
return 0;
}
结果是:p->Print()正常运行,p->Show()崩溃.空指针错误会导致程序崩溃,编译器检查不出来.对于Print函数,并没有对p进行解引用的过程,因此可以正常运行,而Show对this进行了解引用,而this现在是空指针,就会发生崩溃.
void Print(Data* this)
{
cout << "Print()" << endl;
}//没有解引用
void Show(Date* this)
{
cout << this->_a << endl;
}//发生解引用
类的6个默认成员函数
如果一个类中什么成员都没有,我们就称这个类为空类,但空类并不是真的什么都没有,任何类在什么都不写时,编译器会自动生成以下6个默认成员函数。
默认成员函数:用户没有显式实现,编译器会生成的成员函数称为默认成员函数。

构造函数
构造函数指在对象构造时调用的函数,用于完成初始化工作。特征如下:
- 函数名与类名相同。
- 无返回值。
- 对象实例化时编译器自动调用对应的构造函数。
- 构造函数可以重载。 C++入门
- 如果类中没有显式定义构造函数,则C++编译器会自动生成一个无参的默认构造函数,一旦用户显式定义编译器将不再生成。
- 无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。 注意:无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数,都可以认为是默认构造函数,特点在于可以不用传参数。
函数内初始化
class Date
{
private:
int _year;
int _month;
int _day;
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
};
对于我们创建的日期类,想要正确使用就必须提前调用init函数,否则就会出现随机数。为了去除这样的繁琐操作,我们希望每次创建对象时都能自动进行初始化,这个时候就可以使用构造函数。
class Date
{
private:
int _year;
int _month;
int _day;
public:
//构造函数:在对象构造时自动调用的函数
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
Date()
{
_year = 0;
_month = 1;
_day = 1;
}//构造函数的重载
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
};
为了使用这个构造函数,我们需要传参,而它的调用方式较为特殊,在实例化时可以直接进行调用。构造函数的实现依然是依赖于this指针。
int main()
{
Date d1(2025,8,13);
Date d2;//注意不能加括号:Date d2(),否则会报错.
d1.Print();
return 0;
}
由于构造函数可以重载,假设我实例化时不想传参进行初始化,我也可以将构造函数进行重载,不再设定参数。而这两个实则可以合二为一,我们使用全缺省进行实现C++入门,这样我们参数想传几个就传几个
Date(int year=0, int month=1, int day=1)
{
_year = year;
_month = month;
_day = day;
}
那现在有另一个问题:这两个函数是否构成重载?
Date(int year=0, int month=1, int day=1)
{
_year = year;
_month = month;
_day = day;
}
Date()
{
_year = 0;
_month = 1;
_day = 1;
}
显然构成,因为参数不同,但是这两个函数却不能同时存在.如果同时存在,调用的时候会存在歧义.如果在创建对象的时候不传参,就不能确认到底应该调用哪一个.
假设我们不显式定义构造函数,那么就会自动调用编译器生成的无参构造函数.但是问题来了,我们直接创建变量,然后调用了C++的无参构造函数,假设我们不做初始化,得到的结果仍然是随机值,那调用的意义何在?
class Time
{
private:
int _hour;
int _minute;
int _second;
public:
Time()
{
_hour = 0;
_minute = 0;
_second = 0;
}
};
class Date
{
private:
int _year;
int _month;
int _day;
Time _t;
public:
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
};
int main()
{
Date d1;
}
实际上它并不是什么都没做.现在调用了Date的默认构造函数,Date中包含了Time类,虽然Date里的其他成员没有被初始化,但是Time类的成员却被初始化了.也就是说Time的构造函数被成功调用了.所以默认构造函数做的事情为:针对内置成员变量不做处理,针对自定义类型的成员变量会去调用它的构造函数.
初始化列表
刚刚我们使用的初始化方式叫做函数体内赋值,实际上还有一种方式–初始化列表,语法如下:
:初始化成员(初始化变量),初始化成员(初始化变量)
Date(int year=0, int month=1, int day=1)
:_year(year),_month(month),_day(day)
{ }
既然已经能在函数内赋值,为什么还需要初始化列表呢?实际上有几类成员必须在初始化列表初始化.它们是:
引用成员变量,const成员变量和自定义类型成员(且该类没有默认构造函数)
class B
{
public:
B(int n, int ref)
{
_n = n;//error
_ref = ref;//error
}
private:
int& _ref;// 引用
const int _n; // const
};
修改为:
B(int n, int ref)
:_ref(ref) ,_n(10)
{}
那么为什么这些类型的成员只能用初始化列表进行初始化?
private:
int& _ref;// 引用
const int _n; // const
这段代码实际上不是定义,而是声明,真正的定义是在创建变量的时候
B b(1,2)
初始化列表就可以理解为是对象的成员变量进行定义的地方.那么回过来,为什么引用成员变量,const成员变量和自定义类型成员(且该类没有默认构造函数)需要在初始化列表进行初始化.原因是:这三类变量在定义的时候就必须要被初始化.(const变量不能赋值,引用不能为空引用C++入门)
建议使用初始化列表来进行初始化,初始化的顺序就是成员变量声明的顺序,和初始化列表的顺序无关
class A
{
public:
A(int a)
:_a1(a),_a2(_a1)
{}
void Print() {
cout<<_a1<<" "<<_a2<<endl;
}
private:
int _a2;
int _a1;
};
int main() {
A aa(1);
aa.Print();
}
输出结果一个是1,一个是随机值.原因是_a2定义在前面,所以是_a2先初始化,而_a2是被_a1初始化的,此时_a1没有初始化,所以会是一个随机值.实际使用时建议声明和定义顺序一致,这样不容易出错。
explicit关键字
我们之前还写过一段代码
int main()
{
Date d1(1);
Date d2=2;
}
d1是通过构造函数进行的,d2实际上是隐式类型转换,先构造出tmp(2),然后再用拷贝构造拷贝给d2,但是会被编译器优化为直接构造d2(2). 所以Date d2=2就不会造成报错.如果不希望发生这样的隐式类型转换,便可以使用explicit关键字进行修饰
explicit Date(int year=0)
:_year(year)
{ }
此时Date d2=2就会报错,因为2是int型变量,用explicit修饰后缺少了从int到Date的过程。
声明时给缺省值
在C++11以后,还会允许在声明的时候对缺省值进行声明
class Date
{
public:
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year=0;
int _month=1;
int _day=1;
};
int main()
{
Date d1;
d1.Print();
return 0;
}
最终打印的结果为0-1-1,特别强调的是,这不是初始化,初始化必须定义了才能进行,而在private里的东西都是声明,它只是在告诉编译器有这样一个初值。
但是特别需要注意的是,static 类的变量只能在类外进行定义。
拷贝构造函数
class Date
{
private:
int _year;
int _month;
int _day;
public:
Date(int year = 0, int month = 1, int day = 1)//构造函数
{
_year = year;
_month = month;
_day = day;
}
};
int main()
{
Date d1(2025,5,12);
//我希望创建一个与d1完全相同的成员d2
Date d2(2025,5,12);
}
如代码所示,有一个问题。假设现在我的d1变了,那么我的d2只能手动改吗,能不能我的d2直接使用d1进行构造?C++提供了拷贝构造函数。
class Date
{
private:
int _year;
int _month;
int _day;
public:
Date(int year = 0, int month = 1, int day = 1)//构造函数
{
_year = year;
_month = month;
_day = day;
}
Date(Date d)
{
_year=d._year;
_month=d._month;
_day=d._day;
}//err
};
int main()
{
Date d1(0,0,1);
Date d2(d1);
return 0;
}
如果这么写就会出现递归拷贝问题.我们本质上是在调用函数,调用函数就需要进行传参.
这个函数本质上是在传值调用,如果是内置类型,就会直接进行赋值,但是现在是我们的自定义类型,于是需要调用拷贝函数把d1拷贝给d,这个时候又是一个拷贝构造.所以现在的逻辑是:拷贝构造需要传参,而传参又造成了拷贝构造,就无穷递归了.那么为了解决这个问题,我们可以传引用.
Date(Date& d)
{
_year=d._year;
_month=d._month;
_day=d._day;
}
//调用:Date d2(d1)
为什么传引用能解决?如果是引用,传参过程不再是拷贝构造,而是等价于Date& d=d1,d变成了d1的别名, 没有再开辟新的空间.C++入门.那么既然使用了引用,为了防止传进来的东西被更改,可以使用const修饰.
Date(const Date& d)//拷贝构造
{
_year=d._year;
_month=d._month;
_day=d._day;
}
本质上来说,拷贝构造是构造函数的重载.解决了这个问题,我们来考虑一个问题:在C语言中,我们也写过把结构体传入函数做参数的 函数,为什么不会死循环,原因是C语言的对自定义参数的拷贝并不是通过拷贝构造实现的,而是直接把那一块内存进行复制.第二个问题,c++中我写一个函数,函数参数是Date,还会死递归吗?
void Fun(Date d);
答案是不会,因为传入参数后,会调用拷贝构造对参数进行拷贝:Date d(d1),而拷贝构造已经通过引用实现,所以也不会死递归.
现在我把拷贝构造屏蔽,然后运行下面的代码
int main()
{
Date d1(2020, 4, 11);
Date d2(d1);
d1.Print();
d2.Print();
return 0;
}
结果依然可以正确输出,拷贝构造正常完成.回忆一下,拷贝构造是默认成员函数,所以编译器会帮我们默认实现一个拷贝构造.编译器默认生成的拷贝构造会完成按字节逐一进行拷贝(浅拷贝),会直接把对应内存空间之间拷贝给我们创建的对象.
那么问题来了:编译器默认实现了浅拷贝,那我们自己实现拷贝构造的意义在哪?
Class Stack
{
public:
Stack(int n=10)//构造函数自动进行初始化
{
_a=(int*)malloc(sizeof(int)*n);
_size=0;
_capacity=n;
}
//...其他接口
~Stack()//析构函数自动销毁
{
if(_a)
{
free(_a);
_a=nullptr;
_size=_capacity=0;
}
}
private:
DataType* _array;
size_t _capacity;
size_t _size;
};
int main()
{
Stack st1;
Stack st2(st1);
return 0;
}

可以看到拷贝正常完成了,但是再往下走程序就崩溃了.这里就造成了C++中的浅拷贝问题.
st里有a, size,capacity三个部分构成.
初始化st1后会malloc一块空间给a;然后用默认拷贝构造将st1的空间逐字节拷贝到st2的空间上.拷贝过去后st2的_a本该是一块新开辟的空间,但是这样拷贝后st1的_a指针和st2的_a指针指向了同一块空间,这里必然会带来很多问题,但是不至于导致程序崩溃.导致崩溃的点在于:st1和st2出作用域后会调用析构函数,但是st1的_a和st2的_a指向同一块空间.后定义先析构,st2先析构,释放了_a,然后st1又析构一次,同一块空间被释放了两次,最终导致程序崩溃.
为了解决这个问题,我们应当自己实现深拷贝的拷贝构造.这也就是拷贝构造存在的意义.
析构函数
构造函数会在对象定义时自动调用,此外,还会自动调用一次析构函数,与构造函数相反,对象在销毁时会自动调用析构函数,完成对象中资源的清理工作,不是完成对象的销毁。
class Date
{
private:
int _year;
int _month;
int _day;
public:
Date(int year = 0, int month = 1, int day = 1)//构造函数
{
_year = year;
_month = month;
_day = day;
}
~Date()//析构函数
{
cout << "release" << endl;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
};
int main()
{
Date d1;
Date d2;
return 0;
}//打印两个"release"
main函数完成后,函数栈帧被销毁,对象也被销毁,此时便会调用析构函数.
析构函数是特殊的成员函数,其特征如下:
- 析构函数名是在类名前加上字符 ~。
- 无参数无返回值类型。
- 一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。注意:析构函数不能重载
- 对象生命周期结束时,C++编译系统系统自动调用析构函数。
我们上面定义的类并没有什么需要清理的资源,但假如我们定义了一个栈,栈中有一个栈数组,并由malloc分配了空间.那么当函数完成,我们对栈的销毁就可以放到析构函数中自动调用,不需要我们在函数中再次手动调用.
Class Stack
{
public:
Stack(int n=10)//构造函数自动进行初始化
{
_a=(int*)malloc(sizeof(int)*n);
_size=0;
_capacity=n;
}
//...其他接口
~Stack()//析构函数自动销毁
{
if(_a)
{
free(_a);
_a=nullptr;
_size=_capacity=0;
}
}
private:
DataType* _array;
size_t _capacity;
size_t _size;
};
如果我不定义,那么编译器会自动生成一个析构函数,实际上它像构造函数一样,对默认的基本类型不会进行操作,但是会调用类中自定义类型的析构函数
运算符重载
现在我想比较自定义类型的大小
int main()
{
Date d1(0,0,1);
Date d2(d1);
if(d1==d2){}//error
return 0;
}
因为Date类型是我们自定义的类型,编译器并不知道应该如何进行比较,因此此处直接使用运算符就会报错.如果相比较,我们只能通过编写一个函数来进行
bool IsDateEqual(const Date&d1,const Date&d2)
{
//此处省略
}
但是如果类型一多,可读性就下降了;那么如果自定义类型也能使用我们原本就有的运算符,可读性就会上升了.此时就可以使用运算符重载.运算符重载依赖关键字operator实现.
bool operator==(const Date& d1, const Date& d2)
{
return d1._year == d2._year&& d1._month == d2._month&& d1._day == d2._day;
}//把"=="符号附上我们编写的含义.
当进行如下操作后,d1\d2会被编译器转换为operator\(d1,d2),实际上你也可以手动这么调用.
int main()
{
Date d1(2024,5,12);
Date d2(d1);
d1 == d2;
operator==(d1, d2);//但是一般不这么写
d2.Print();
return 0;
}
但是有个问题,类的成员变量是私有的,无法在类外被访问,会报错.为了解决这个问题,我们可以把这个东西定义为成员函数.
class Date
{
private:
int _year;
int _month;
int _day;
public:
Date(int year = 0, int month = 1, int day = 1)//构造函数
{
_year = year;
_month = month;
_day = day;
}
Date(const Date& d)//拷贝构造
{
_year = d._year;
_month = d._month;
_day = d._day;
}
bool operator==(const Date& d1, const Date& d2)
{
return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}
};
然后又报错了,operator的参数太多.”\“符号我们设置的有两个参数,而实际上有三个,因为还有一个隐藏的this指针.我们这里调用d1\d2会被编译器翻译为:d1.operator\==(&d1,d2);(注意这里&是取地址,取给this指针).所以我们要修改这个函数:
bool operator==(const Date& d2)
{
return _year == d2._year && _month == d2._month && _day == d2._day;
}
现在再调用d1\d2就会被翻译为d1.operator\(&d1,d2),operator\==相当于我们类中的一个成员函数;同理可以编写>的重载
bool operator>(const Date& d2) const
{
if (_year > d2._year) return true;
if (_year < d2._year) return false;
if (_month > d2._month) return true;
if (_month < d2._month) return false;
return _day > d2._day;
}
运算符的重载有一些规则:
1.不能通过连接其他符号来创建新的操作符:比如operator@
2.重载操作符必须有一个类类型参数
3.用于内置类型的运算符,其含义不能改变,例如:内置的整型+,不能改变其含义
4.作为类成员函数重载时,其形参看起来比操作数数目少1,因为成员函数的第一个参数为隐藏的this
5.., :: , sizeof , ? : , . 注意以上5个运算符不能重载。(注意.是一个操作符,极为少用).
Date d1(2020, 4, 11);
Date d3;
d3 = d1;
d1.Print();
d3.Print();
return 0;
发现依然可以正确输出,我们并没有对”=”进行重载,也就是说,”=”也和构造函数一样,被编译器默认定义为了浅拷贝.
所以,某些符号实际上并不需要我们进行手动重载,因为编译器生成的就可以使用.
特殊的,在重载的时候我们应该如何区分前置++和后置++
//++d1
Date& operator++()
{
*this+=1;
return *this;
}
这样写默认是前置++,为了实现后置++并构成重载,我们需要把它区分开来,所以设计了一个int参数来构成重载,但是这个参数并不会被使用。并且因为是后置++,返回值是++前的,所以需要额外进行保存。
//d1++
Date operator++(int)
{
Date tmp(*this);
*this += 1;
return tmp;
}
&与const&的重载
既然&是运算符,就可以发生重载,不过几乎不会用到.
Date* operator&(){
return this ;
}
const Date* operator&()const
{
return this ;
}
const成员
现在我编写如下函数
void f(const Date& d)
{
d.Print();
}
结果报错,也就是说传过来的d不能调用print。原因是:d.Print实际上是d.Print(&d),然后Print函数那边实际上是Print(Date* this).我传过去的是const Date的指针,却传到了Date上,权限放大了C++入门.为了解决这个问题,我们可以把Print的变量也变成const的
void Print() const
{
cout << _year << "-" << _month << "-" << _day << endl;
}
这样在调用的时候就变成了Print(const Date*this),但是被const修饰以后意味着不能在这里面修改成员变量.
const Datep1和Date const *p1修饰的都是p1,而Date* const p1修饰的是p1
那么同样的
class F {
public:
void f1() {
}
void f2() const
{
f1();
}
};
f2的变量是一个const F型的,f1的变量则是Fthis,传参的过程中权限发生了放大,同样也会发生报错.
- const对象不可以调用非const成员函数
- 非const对象可以调用const成员函数
- const成员函数内不可以调用其它的非const成员函数
- 非const成员函数内可以调用其它的const成员函数
static成员
例:设计一个类A,可以计算这个类总计产生了多少个对象
首先明确一个事情:对象都是由构造函数或者拷贝构造产生的,每调用一次都会产生一个对象.
int n;
class A
{
public:
A()
{
n++;
}
A(const A& a)
{
n++;
}
};
这个代码能实现功能,但是有问题.n是全局变量,所以谁都可以对n进行操作.这不满足我们C++的封装优势.所以我们要把n放到类中,但是这样就算不出n了,因为每个对象都产生了一个n,加不到同一个n上,此时用static修饰,就可以理解为这个n变成了所有对象共享的n.但是此时只有声明,还需要在类外进行定义,并且指明这个n是属于A类的.
class A
{
public:
A()
{
n++;
}
A(const A& a)
{
n++;
}
private:
static int n;
};
int A::n=0;
但是由于是私有的,在类外即使定义了也没法被访问,为了能够被使用,还需要编写一个函数来获取n的值.
static int GetN()
{
return n;
}
这样拿到的数值就只能读不能改了,但是如果有人进行修改也不会发生报错,所以实际上可以通过const限定符进行修饰然后引用返回,这样在外面进行修改的时候就会报错.
class A
{
public:
A()
{
n++;
}
A(const A& a)
{
n++;
}
const int& GetN()
{
return n;
}
private:
static int n;
};
int A::n = 0;
int main()
{
A a;
const int &ret = a.GetN();
cout << ret << endl;
return 0;
}
注意:
1.static成员变量不存在对象中,存在静态区,属于这个类的所有对象,也是属于这个类
2.static成员函数没有this指针,而非静态成员函数需要通过this指针进行访问,因此不能访问任何非静态成员。
class A{
void f1()
{
}
static void f2()
{
f1();//error
}
}
由于静态函数f2没有this指针.而f1是有个隐含的this指针的.这样调用f1的时候就变成了
static void f2()
{
f1(A* this);//error
}
但是静态成员函数没有this指针,所以就报错了.而非静态成员函数可以调用静态类成员函数.
class A{
void f1()
{
f2();
}
static void f2()
{
}
}
友元
友元函数
现在我编写一个函数
void f(Date& d)
{
d._year = 10;
cout << d._year << endl;
}
此时会报错,因为Date的成员是私有的,私有的东西不可以在类外被访问。但如果确实有在类外访问的需要呢?此时就可以在类中声明,告诉类这个函数可以对成员进行访问,这就是友元
class Date
{
friend void f(Date& d);//声明友元函数
public:
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year=0;
int _month=1;
int _day=1;
};
而有的地方是必须使用友元的,比如我的输出习惯使用cout,不喜欢去调用d1.Print(),那么我就可以对<<进行重载.
cout的实现方式是把需要输出的数据传到一个叫ostream类型的变量中,由此我们进行重载
class Date
{
friend void f(Date& d);
public:
void operator<<(ostream& out)
{
out << _year << "/" << _month << "/" << _day<<endl;
}
private:
int _year=0;
int _month=1;
int _day=1;
};
int main()
{
Date d1;
cout<<d1;
return 0;
}
此时报了一万个错,但是如果我们展开调用
d1.operator<<(cout);
或
d1<<cout
这两个代码也正常工作了.它和我们正常写的反过来了.在重载时我们介绍过,重载有一个隐含的参数”this”指针,默认为第一个参数.所以调用下面两个显然没问题,this指向d1,ostream为cout.但是代码可读性却下降了,变成了cout流向了d1.这里就说明一个问题:<<的重载不能写为成员函数.
我们回顾下为什么重载要写在成员函数中,原因是因为类中方便访问成员函数.但是在这里cout必须作为第一个参数,而如果写在类中,会被this指针抢占,所以只能定义到外面.那么为了让它能够访问私有变量,就需要使用友元.
class Date
{
friend void operator<<(ostream& out, const Date& d1);
public:
private:
int _year=0;
int _month=1;
int _day=1;
};
void operator<<(ostream& out,const Date& d1)
{
out << d1._year << "/" << d1._month << "/" << d1._day << endl;
}
int main()
{
Date d1;
cout << d1;
return 0;
}
此时cout << d1就被翻译为
operator<<(cout,d1);
此外有的时候会有连续输出的需求
cout<<d1<<d2
此时出现报错,和之前的连等一样,cout<<执行完成只会会有一个返回值,返回后继续提供给下一个执行.而我们目前的写法没有返回,所以默认为空,就会出现报错.
ostream& operator<<(ostream& out,const Date& d1)
{
out << d1._year << "/" << d1._month << "/" << d1._day << endl;
return out;
}
同样的,也可也实现>>的重载
istream& operator>>(istream& in, Date& d1)
{
in >> d1._year >> d1._month >> d1._day;
return in;
}
因为需要从in中拿东西给d1,所以d1不可以用const修饰.输入时中间可以直接用空格/换行隔开.而且这里d1必须传入引用,否则输入的东西带不出去.
C++的输入输出可以自动识别类型,它的本质是函数重载C++入门,即函数名相同而参数不同.当参数数据类型不同时,调用的实际上是不同的函数.
友元类
有的时候,一个类需要对另一个类的成员进行访问,此时就可以使用友元类
class Date
{
friend class Time;
public:
Date(int year = 1900, int month = 1, int day = 1)
:_year(year),_month(month),_day(day)
{}
private:
int _year;
int _month;
int _day;
void SetTimeOfDate(int hour, int minute, int second)
{
// 直接访问时间类私有的成员变量
_t._hour = hour;
_t._minute = minute;
_t._second = second;
}
Time _t;
};
内部类
类中又定义了一个类,一般来说很少用,除非这个类生来就是为另一个类服务的。
class A
{
private:
static int k;
int h;
public:
class B // B天生就是A的友元
{
public:
void foo(const A& a)
{
cout << k << endl;//OK
cout << a.h << endl;//OK
}
};
};
内部类天生就是其类的友元。
匿名对象
除了常规的创建对象的方法,还可以这样
int main()
{
Date().Print();
return 0;
}
它和常规对象的创建的区别在于它没有名字,这样就是匿名对象。它的使用方式在于:我只会在该处这一行使用,其他地方不会再进行使用了,匿名对象的声明周期只在这一行.所以上面的这一行代码实际上调用了构造函数,Print(),和析构函数.
补充:一个完善的日期类
为了加深理解,我们现在来编写一个完善的日期类.
构造函数:
首先来想想我们之前编写的日期类有什么问题:
class Date
{
public:
Date(int year = 0, int month = 1, int day = 1)//构造函数
{
_year = year;
_month = month;
_day = day;
}
void Print()//打印函数
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
构造函数直接通过赋值进行,但是日期对月和日是有要求的,因此需要进行额外的判断
if (year >= 0 && month>=1 && month <=12 && day>=1 && day<=?)//输入合法性判断
由于每个月的天数不同,这里的合法性判断就不好直接做,因此再写一个函数用来判断每个月的天数:
int GetMonthDay(int year, int month)//获取某年某月的天数
{
int monthDays[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
if (month == 2&& (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
{
//判断是不是闰年的2月
return 29;
}
return monthDays[month];
}
而monthDay这个数组是不会被修改的,所以直接改成static类型,这样不需要每次调用的时候都进行创建.然后利用该函数优化我们的构造函数即可
Date(int year = 0, int month = 1, int day = 1)//构造函数
{
if (year >= 0 && month>=1 && month <=12 && day>=1 && day<= GetMonthDay(year,month))//输入合法性判断
{
_year = year;
_month = month;
_day = day;
}
else
{
cout << "日期不合法" << endl;
}
}
由于没有空间需要进行释放,因此不需要写析构函数,我们来写拷贝构造
拷贝函数
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
运算符的重载
比较运算符
然后可以编写一些比较运算符重载为我们的日期类进行比较功能上的拓展.
// < 的重载
bool operator<(const Date& d)
{
if (_year > d._year) return false;
if (_year < d._year) return true;
//年相同,比月
if (_month > d._month) return false;
if (_month < d._month) return true;
//月相同,比日
if (_month >= d._month) return false;
return true;
}
// == 的重载
bool operator==(const Date& d)
{
return _year = d._year && _month == d._month && _day == d._day;
}
// <= 的重载
bool operator<=(const Date& d)//<=
{
return (*this < d )|| (*this == d);
}
// > 的重载
bool operator>(const Date& d)
{
return !(*this <= d);
}
// >= 的重载
bool operator>=(const Date& d)
{
return !(*this < d);
}
// != 的重载
bool operator!=(const Date& d)
{
return !(*this == d);
}
实际上实现一个后剩下的都可以复用实现,这样的好处在于如果类有了修改,只需要改最开始的两个就可以.这一段重载反复调用了我们重载的”\==”和”<“符号,为了减少开销,我们可以用inline修饰为内联函数C++入门,不过因为是定义在类里面的,编译器自动帮我们做了这件事.
软件工程里提倡低耦合,高内聚.耦合度和内聚的侧重于强调类/模块的内部成员的关系.
耦合指类与类之间的关系,类与类之间关系越小越好,这样一个类有bug不会影响其他的类;
内聚指一个类内部成员之间的关系.刚刚写的操作符重载大量使用了复用本质上是提高了代码的内聚度.
计算运算符
此外,日期还可以进行加减,不过日期+日期没有意义,只能加天数.所以是否对一个运算符进行重载,看的是这个运算符是否对该对象有意义.所以还可以继续编写日期的运算重载
// + 的重载
Date operator+(int Day)
{
Date ret(*this);
ret._day += Day;
while (ret._day >GetMonthDay(ret._year, ret._month))
{
ret._day -= GetMonthDay(ret._year, ret._month);
ret._month++;
if (ret._month > 12)
{
ret._month-=12;
ret._year++;
}
}
return ret;
}
// += 的重载
void operator+=(int Day)
{
_day += Day;
while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
_month++;
if (_month > 12)
{
_month -= 12;
_year++;
}
}
}
//++d1
Date& operator++()
{
*this+=1;
return *this;
}
//d1++
Date operator++(int)
{
Date tmp(*this);
*this += 1;
return tmp;
}
为了分别重载前置++和后置++,我们给第二个++补上一个int参数,这个参数没有任何意义,制数为了单纯能使其能构成重载。
此外,由于this出了作用域依然存在,因此也可以使用引用返回C++入门.
Date& operator+=(int Day)
{
_day += Day;
while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
_month++;
if (_month > 12)
{
_month -= 12;
_year++;
}
}
return *this;
}
而且,+依然可以通过+=进行复用。
Date operator+(int Day)
{
Date ret(*this);
ret += Day;
return ret;
}
然后是赋值:
// = 的重载
void operator=(const Date& d)
{
if (this != &d)//防止自己给自己赋值
{
_day = d._day;
_month = d._month;
_year = d._year;
}
}
但是我们正常写赋值的时候是可以连续赋值的
int i=0,j=1,k=2;
i=j=k;
j=k,返回j,然后返回值j再赋值给i.所以我们还可以修改我们的=重载.由于出了作用域*this对象还在,所以可以引用返回.C++入门.
Date& operator=(const Date& d)
{
if (this != &d)
{
_day = d._day;
_month = d._month;
_year = d._year;
}
return *this;
}
特别注意:
Date d1(2025,8,19);
Date d4=d1;
这里对d4的创建实际上是拷贝构造,不是=的重载.因为这里d4还不存在,这里是在用d1去初始化d4,是一个构造的过程,所以调用了拷贝构造.也就是说,即使没有写”=”符号的重载也可以这么写,因为它并没有调用.不过前面已经说过”=”即使没有定义编译器也默认为浅拷贝,因此实际上不需要我们手动实现.
然后是减法的实现。对于日期而言,两个日期相减得到的是这两个日期的差值;日期减一个常数得到的是该日期的常数天前。
Date& operator-=(int day)
{
while(day >= _day)
{
_month--;
_day += GetMonthDay(_year, _month);
if (_month == 0)
{
_month += 12;
_year--;
}
}
_day -= day;
return *this;
}
Date operator-(int day)
{
Date ret(*this);
ret -= day;
return ret;
}
//--d1;
Date& operator--()
{
*this -= 1;
return *this;
}
//d1--
Date operator--(int)
{
Date tmp(*this);
*this -= 1;
return tmp;
}
但是到目前为止,我们的代码存在一个问题。如果我们+=一个负数或者-=一个负数,输出的结果都是有问题的,中间涉及到一个转换,实际上只是多了 一个额外的判断
Date& operator+=(int Day)
{
if (Day > 0) {
_day += Day;
while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
_month++;
if (_month > 12)
{
_month -= 12;
_year++;
}
}
return *this;
}
else
return *this -= -Day;
}
Date& operator-=(int day)
{
if (day > 0) {
while (day >= _day)
{
_month--;
_day += GetMonthDay(_year, _month);
if (_month == 0)
{
_month += 12;
_year--;
}
}
_day -= day;
return *this;
}
else
{
return *this += -day;
}
}
然后是日期-日期。日期-日期实际上不太好实现,但是我们可以使用小的去加,看加了多少次能到大的。
int operator-(const Date& d)
{
Date max = *this;
Date min = d;
if (min > max)
{
max = d;
min = *this;
}
int gap = 0;
while (min != max)
{
min++;
gap++;
}
return gap;
}
注意:Date min=d是把d拷贝给了min,不存在权限越界的问题,如果是Date& min=d就会报错,现在这个代码只能返回正值,而判断谁大谁小的逻辑我们已经判断过,只需要添加标志位就可以。
int operator-(const Date& d)
{
Date max = *this;
Date min = d;
int flag = 1;
if (min > max)
{
max = d;
min = *this;
flag = -1;
}
int gap = 0;
while (min != max)
{
min++;
gap++;
}
return gap*flag;
}
汇总
//实现一个完善的日期类
class Date
{
public:
int GetMonthDay(int year, int month)//获取某年某月的天数
{
static int monthDays[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
if (month == 2&& (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
{
//判断是不是闰年的2月
return 29;
}
return monthDays[month];
}
//运算符重载
bool operator<(const Date& d)//<
{
if (_year > d._year) return false;
if (_year < d._year) return true;
//年相同,比月
if (_month > d._month) return false;
if (_month < d._month) return true;
//月相同,比日
if (_month >= d._month) return false;
return true;
}
bool operator==(const Date& d)
{
return _year = d._year && _month == d._month && _day == d._day;
}
bool operator<=(const Date& d)//<=
{
return (*this < d )|| (*this == d);
}
bool operator>(const Date& d)
{
return !(*this <= d);
}
bool operator>=(const Date& d)
{
return !(*this < d);
}
bool operator!=(const Date& d)
{
return !(*this == d);
}
Date operator+(int Day)
{
Date ret(*this);
ret += Day;
return ret;
}
Date& operator+=(int Day)
{
if (Day > 0) {
_day += Day;
while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
_month++;
if (_month > 12)
{
_month -= 12;
_year++;
}
}
return *this;
}
else
return *this-= -Day;
}
//++d1
Date& operator++()
{
*this+=1;
return *this;
}
//d1++
Date operator++(int)
{
Date tmp(*this);
*this += 1;
return tmp;
}
Date& operator=(const Date& d)
{
if (this != &d)
{
_day = d._day;
_month = d._month;
_year = d._year;
}
return *this;
}
Date& operator-=(int day)
{
if (day > 0) {
while (day >= _day)
{
_month--;
_day += GetMonthDay(_year, _month);
if (_month == 0)
{
_month += 12;
_year--;
}
}
_day -= day;
return *this;
}
else
{
return *this += -day;
}
}
Date operator-(int day)
{
Date ret(*this);
ret -= day;
return ret;
}
//--d1;
Date& operator--()
{
*this -= 1;
return *this;
}
//d1--
Date operator--(int)
{
Date tmp(*this);
*this -= 1;
return tmp;
}
int operator-(const Date& d)
{
Date max = *this;
Date min = d;
int flag = 1;
if (min > max)
{
max = d;
min = *this;
flag = -1;
}
int gap = 0;
while (min != max)
{
min++;
gap++;
}
return gap*flag;
}
Date(int year = 0, int month = 1, int day = 1)//构造函数
{
if (year >= 0 && month >= 1 && month <= 12 && day >= 1 && day <= GetMonthDay(year, month))//输入合法性判断
{
_year = year;
_month = month;
_day = day;
}
else
{
cout << "日期不合法" << endl;
}
}
Date(const Date& d)//拷贝构造
{
_year = d._year;
_month = d._month;
_day = d._day;
}
void Print()//打印函数
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
为了规范,声明和定义常常会进行分离,即在函数声明在类中.h文件下,定义在.c文件下
.h文件
class Date{
public:
int GetMonthDay(int year, int month);
bool operator==(const Date& d);
...
}
.c文件
int Date::GetMonthDay(int year, int month)//获取某年某月的天数
{
static int monthDays[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
if (month == 2&& (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
{
//判断是不是闰年的2月
return 29;
}
return monthDays[month];
}
bool Date::operator==(const Date& d)
{
return _year = d._year && _month == d._month && _day == d._day;
}
...
其他函数也同样可以进行修改.但是截止目前我们实现的日期类依然还有问题.
int operator-(const Date& d)
{
Date max = *this;
Date min = d;
if (min > max)
{
max = d;
min = *this;
}
int gap = 0;
while (min != max)
{
min++;
gap++;
}
return gap;
}
void Fun(const Date&d1,const Date&d2)
{
cout<<d1-d2<<endl;
}
我们发现会出现报错,首先”-“被我们重载为内联函数,但是内联函数必须在原地进行展开,所以声明和定义不可以被分开.修改后依然报错,d1-d2会被翻译为
d1.operator-(&d1,d2);
d2是个const Date的引用,应当传到const Date&上,这里是正确的,这也就是为什么在编写的时候使用引用传参一般都加上了const,这样可以避免出现权限的放大.但是对于传入的&d1,传入的是const Date的指针,但是却被Date接收了,权限出现了放大,所以需要将operator-用const进行修饰
int operator-(const Date& d) const
{
Date max = *this;
Date min = d;
if (min > max)
{
max = d;
min = *this;
}
int gap = 0;
while (min != max)
{
min++;
gap++;
}
return gap;
}
所以实际上,只要在成员函数中不需要对成员变量进行修改,建议都添加上const.
习题
求和
求1+2+3+…+n,要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句(A?B:C).数据范围: 0<n≤200
进阶: 空间复杂度 O(1) ,时间复杂度 O(n).
分析:这道题核心的问题在于如何控制程序只走n次
方案1:使用递归进行求和,但是结束条件由于不允许使用if,所以可以用与作为结束条件.
方案2:使用类+构造函数+static成员.
定义一个Sum类,然后在Solution里面定义一个长为n的Sum数组,这样就会调用n次构造函数,于是就实现了对程序执行n次的控制
class Sum{
public:
Sum()
{
_sum+=_i;
_i++;
}
static int GetSum()
{
return _sum;
}
private:
static int _i;
static int _sum;
};
int Sum::_i=1;
int Sum::_sum=0;
class Solution {
public:
int Sum_Solution(int n) {
Sum a[n];
return Sum::GetSum();
}
};
但是我定义了个长度为n的数组能用Sum a[n]吗?这玩意是个变长数组,不是所有C标准都支持.而且为了保证能够多次测试,每次完成一次返回后都要把sum和i清零
class Sum{
public:
Sum()
{
_sum+=_i;
_i++;
}
static void Init()
{
_i=1;
_sum=0;
}
static int GetSum()
{
int ret=_sum;
_sum=0;
_i=1;
return ret;
}
private:
static int _i;
static int _sum;
};
int Sum::_i=1;
int Sum::_sum=0;
class Solution {
public:
int Sum_Solution(int n) {
Sum::Init();
Sum*p = new Sum[n];
return Sum::GetSum();
}
};
析构顺序?
现有四个类ABCD,则程序中ABCD的构造顺序为?析构顺序为?
C c;
int main()
{
A a;
B b;
static D d;
return 0;
}
析构顺序为BADC.因为C是全局变量,D是static变量,都是定义在main函数前的,所以CD肯定在AB后析构.而C定义在D之前,所以C比D后析构,最后顺序为BADC
而构造顺序为CABD,因为只有走到static D d时才会构造d,所以构造顺序为CABD.
这也提示我们:构造顺序和析构顺序不一定是完全相反的.
拷贝次数?
下列代码调用了多少次拷贝构造
Widget f(Widget u)
{
Widget v(u);
Widget w=v;
return w;
}
int main()
{
Widget x;
Widget y=f(f(x));
}
本体实际上涉及到了编译器优化的问题.首先分析调用一次f(x)会调用多少次构造.
因为是传值调用,所以x会拷贝给u,然后函数内用u初始化v还是拷贝构造,然后v赋给w在进行一次拷贝,最后返回还是传值,需要拷贝一个w给临时变量进行返回.所以执行一次f共需要4次拷贝.
所以调了两次f共8次,然后把f(f(x))的返回值赋值给y,又多了一次,所以一共9次?理论上来说确实是9次,但是编译器会对这个过程进行优化.优化一般会发生在返回和传参的地方.
嵌套调用f(f(x))时,f(x)返回时创建一个临时变量作为w的拷贝并返回,传入给外层f后,本来需要将传入的东西拷贝给u,但是因为本身接收到的就是临时变量,因此就省略了这一步;最后return的时候创建一个临时变量进行拷贝,拷贝完后赋值给y.这两步也是连续的,会被优化为一个步骤.所以一共会发生7次拷贝构造.

