目录
C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用解决问题。
C++是基于面向对象的,关注的是对象,将一件事情拆分成不同的对象,靠对象之间的交互完成。
C 语言结构体中只能定义变量,在 C++ 中,结构体内不仅可以定义变量,也可以定义函数。比如:之前在数据结构初阶中,用 C 语言方式实现的栈,结构体中只能定义变量 ;现在以 C++ 方式实现, 会发现 struct 中也可以定义函数。
- class className
- {
- // 类体:由成员函数和成员变量组成
- }; // 一定要注意后面的分号
class为定义类的关键字,ClassName为类的名字,{}中为类的主体,注意类定义结束时后面分号不能省略。类体中内容称为类的成员:类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数


【访问限定符说明】1. public 修饰的成员在类外可以直接被访问2. protected 和 private 修饰的成员在类外不能直接被访问 ( 此处 protected 和 private 是类似的 )3. 访问权限 作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止4. 如果后面没有访问限定符,作用域就到 } 即类结束。5. class 的默认访问权限为 private , struct 为 public( 因为 struct 要兼容 C)注意:访问限定符只在编译时有用,当数据映射到内存后,没有任何访问限定符上的区别
- class Person
- {
- public:
- void PrintPersonInfo();
- private:
- char _name[20];
- char _gender[3];
- int _age;
- };
- // 这里需要指定PrintPersonInfo是属于Person这个类域
- void Person::PrintPersonInfo()
- {
- cout << _name << " "<< _gender << " " << _age << endl;
- }
1. 类是对对象进行描述的 ,是一个 模型 一样的东西,限定了类有哪些成员,定义出一个类 并没 有分配实际的内存间 来存储它;比如:入学时填写的学生信息表,表格就可以看成是一个类,来描述具体学生信息。
- int main()
- {
- Person._age = 100; // 编译失败:error C2059: 语法错误:“.”
- return 0;
- }
Person类是没有空间的,只有Person类实例化出的对象才有具体的年龄。
- class Date
- {
- public:
- void Init(int year, int month, int day)
- {
- _year = year;
- _month = month;
- _day = day;
- }
- void Print()
- {
- cout << _year << "-" << _month << "-" << _day << endl;
- }
- private:
- int _year;
- int _month;
- int _day;
- };
- int main()
- {
- Date d1;
- d1.Init(2022, 7, 5);
- d1.Print();
- Date d2;
- d2.Init(2022, 7, 6);
- d2.Print();
- return 0;
- }
1. 函数名与类名相同。2. 无返回值。3. 对象实例化时编译器 自动调用 对应的构造函数。4. 构造函数可以重载。
关于编译器生成的默认成员函数,很多童鞋会有疑惑:不实现构造函数的情况下,编译器会
解答:C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型,如:int/char...,自定义类型就是我们使用class/struct/union等自己定义的类型,看看下面的程序,就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。
class Time { public: Time() { cout << "Time()" << endl; _hour = 0; _minute = 0; _second = 0; } private: int _hour; int _minute; int _second; }; class Date { private: // 基本类型(内置类型) int _year; int _month; int _day; // 自定义类型 Time _t; }; int main() { Date d; return 0; }注意: C++11 中针对内置类型成员不初始化的缺陷,又打了补丁,即: 内置类型成员变量在类中声明时可以给默认值 。
- class Time
- {
- public:
- ~Time()
- {
- cout << "~Time()" << endl;
- }
- private:
- int _hour;
- int _minute;
- int _second;
- };
- class Date
- {
- private:
- // 基本类型(内置类型)
- int _year = 1970;
- int _month = 1;
- int _day = 1;
- // 自定义类型
- Time _t;
- };
- int main()
- {
- Date d;
- return 0;
- }
- // 程序运行结束后输出:~Time()
- // 在main方法中根本没有直接创建Time类的对象,为什么最后会调用Time类的析构函数?
- // 因为:main方法中创建了Date对象d,而d中包含4个成员变量,其中_year, _month, _day三个是
- // 内置类型成员,销毁时不需要资源清理,最后系统直接将其内存回收即可;而_t是Time类对象,所以在
- // d销毁时,要将其内部包含的Time类的_t对象销毁,所以要调用Time类的析构函数。但是:main函数
- // 中不能直接调用Time类的析构函数,实际要释放的是Date类对象,所以编译器会调用Date类的析构函
- // 数,而Date没有显式提供,则编译器会给Date类生成一个默认的析构函数,目的是在其内部调用Time
- // 类的析构函数,即当Date对象销毁时,要保证其内部每个自定义对象都可以正确销毁
- // main函数中并没有直接调用Time类析构函数,而是显式调用编译器为Date类生成的默认析构函数
- // 注意:创建哪个类的对象则调用该类的析构函数,销毁那个类的对象则调用该类的析构函数
若未显式定义,编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝,这种拷贝叫做浅拷贝,或者值拷贝
拷贝构造函数典型调用场景:使用已存在对象创建新对象函数参数类型为类类型对象函数返回值类型为类类型对象![]()
C++ 为了增强代码的可读性引入了运算符重载 , 运算符重载是具有特殊函数名的函数,也具有其返回值类型,函数名字以及参数列表,其返回值类型与参数列表与普通的函数类似。函数名字为:关键字 operator 后面接需要重载的运算符符号 。
参数类型:const T&,传递引用可以提高传参效率返回值类型:T&,返回引用可以提高返回的效率,有返回值目的是为了支持连续赋值检测是否自己给自己赋值返回*this :要复合连续赋值的含义
16.取地址及const取地址操作符重载
17.1 构造函数体赋值
- class Date
- {
- public:
- Date(int year, int month, int day)
- {
- _year = year;
- _month = month;
- _day = day;
- }
- private:
- int _year;
- int _month;
- int _day;
- };
虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称为对对象中成员变量的初始化, 构造函数体中的语句只能将其称为赋初值 ,而不能称作初始化。因为 初始化只能初始 化一次,而构造函数体内可以多次赋值 。
【注意】1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)2. 类中包含以下成员,必须放在初始化列表位置进行初始化:引用成员变量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 };3. 尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量, 一定会先使用初始化列表初始化。
class Time { public: Time(int hour = 0) :_hour(hour) { cout << "Time()" << endl; } private: int _hour; }; class Date { public: Date(int day) {} private: int _day; Time _t; }; int main() { Date d(1); }4. 成员变量 在类中 声明次序 就是其在初始化列表中的 初始化顺序,与其在初始化列表中的先后次序无关
1. 静态成员为所有类对象所共享,不属于某个具体的对象,存放在静态区2. 静态成员变量必须在类外定义,定义时不添加static关键字,类中只是声明3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问4. 静态成员函数没有隐藏的this指针,不能访问任何非静态成员5. 静态成员也是类的成员,受public、protected、private 访问限定符的限制
- class Date
- {
- public:
- Date(int year, int month, int day)
- : _year(year)
- , _month(month)
- , _day(day)
- {}
- // d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
- // 因为成员函数第一个参数一定是隐藏的this,所以d1必须放在<<的左侧
- ostream& operator<<(ostream& _cout)
- {
- _cout << _year << "-" << _month << "-" << _day << endl;
- return _cout;
- }
- private:
- int _year;
- int _month;
- int _day;
- };
友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在
- class Date
- {
- friend ostream& operator<<(ostream& _cout, const Date& d);
- friend istream& operator>>(istream& _cin, Date& d);
- public:
- Date(int year = 1900, int month = 1, int day = 1)
- : _year(year)
- , _month(month)
- , _day(day)
- {}
- private:
- int _year;
- int _month;
- int _day;
- };
- ostream& operator<<(ostream& _cout, const Date& d)
- {
- _cout << d._year << "-" << d._month << "-" << d._day;
- return _cout;
- }
- istream& operator>>(istream& _cin, Date& d)
- {
- _cin >> d._year;
- _cin >> d._month;
- _cin >> d._day;
- return _cin;
- }
- int main()
- {
- Date d;
- cin >> d;
- cout << d << endl;
- return 0;
- }
友元函数可访问类的私有和保护成员,但不是类的成员函数友元函数不能用const修饰友元函数可以在类定义的任何地方声明,不受类访问限定符限制一个函数可以是多个类的友元函数友元函数的调用与普通函数的调用原理相同
- 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;
- };
注意:内部类就是外部类的友元类,参见友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
- 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 A::k = 1;
- int main()
- {
- A::B b;
- b.foo(A());
-
- return 0;
- }
- class A
- {
- public:
- A(int a = 0)
- :_a(a)
- {
- cout << "A(int a)" << endl;
- }
- ~A()
- {
- cout << "~A()" << endl;
- }
- private:
- int _a;
- };
- class Solution {
- public:
- int Sum_Solution(int n) {
- //...
- return n;
- }
- };
- int main()
- {
- A aa1;
- // 不能这么定义对象,因为编译器无法识别下面是一个函数声明,还是对象定义
- //A aa1();
- // 但是我们可以这么定义匿名对象,匿名对象的特点不用取名字,
- // 但是他的生命周期只有这一行,我们可以看到下一行他就会自动调用析构函数
- A();
- A aa2(2);
- return 0;
- }