目录

内存分区：代码区，全局区，栈区，堆区程序运行前：代码区，全局区程序运行后：栈区，堆区引用--给变量起别名注意事项引用做函数参数引用做函数返回值引用的本质---指针常量(值可变，指向不可变)常量引用函数提高默认参数函数占位参数☆函数重载☆☆类和对象：封装，继承，多态封装: 权限，属性，方法属性，方法访问权限: public protected privatestruct 和 class 区别 : 默认访问权限不同成员属性设置为私有private对象的初始化和清理--构造函数(初始化)，析构函数(清理)构造函数和析构函数构造函数的分类及调用:两分类三调用拷贝构造函数调用时机存在问题(返回值优化)：vs和vscode运行结果不同构造函数调用规则☆深拷贝与浅拷贝（释放内存）初始化列表（初始化属性）类对象作为类成员静态成员（成员变量，成员函数，static）

内存分区：代码区，全局区，栈区，堆区

程序运行前：代码区，全局区

程序运行后：栈区，堆区

数据保留一次

//栈区：局部变量int a=10;// 堆区:程序员开辟new，释放delete,int *p=new int(10); // 返回的是整型数据10存放的地址编号

int *p = new int(10); //开辟delete p; //释放

int *arr = new int[10]; //10个元素 返回首地址\for(int i=0;i<10;i++){arr[i]=100+i;}delete[] arr;

引用–给变量起别名

数据类型 &别名 = 原名

int a=10;int &b=a; //别名 b ，指向同一块内存

注意事项

引用必须初始化；

error: int &b;

引用初始化后不可以改变（不可以再当其他变量的别名）

int &b=a;int c=20;error: &b=c;

引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参；优点：可以简化指针修改实参；

#include <iostream>using namespace std;void swap(int &a,int &b){int temp;temp=a;a=b;b=temp;}int main(){int a=10,b=20;swap(a,b);cout<<"a:"<<a<<endl;cout<<"b:"<<b<<endl;//system("pause");return 0;}

引用做函数返回值

notice： 不要返回局部变量引用；---可以返回静态变量引用返回引用，则函数调用可以作为左值；

#include <iostream>using namespace std;int& test(){// 静态变量，存放在全局区，全局区上的数据在程序结束后由系统释放static int a=10; return a;}int main(){// ref 指向 a对应的内存空间int &ref=test();cout<<ref<<endl;cout<<ref<<endl;// 修改原值 ：可看做直接对a进行操作test()=100; cout<<ref<<endl;cout<<ref<<endl;return 0;}

引用的本质—指针常量(值可变，指向不可变)

常量引用

修饰形参，防止误操作

#include <iostream>using namespace std;int showData(const int &a){//a=10;cout<<a<<endl;}int main(){int a=100;const int &ref=10;showData(a);return 0;}

函数提高

默认参数

注意事项如果某个位置已经有默认参数，呢么从这个位置往后，从左到右都必须有默认值；如果函数声明有默认参数，函数实现就不能有默认参数；(error：重定义默认参数)

函数占位参数

占位参数也可以有默认参数

返回值类型 函数名 (数据类型){}void func(int a,int)

☆函数重载

作用：函数名可以相同，提高复用性注意： 函数返回值不可以作为函数重载的条件

函数重载需满足条件：

同一个作用域下；函数名相同；函数参数类型不同或个数不同或顺序不同

注意事项：（坑）

引用作为重载条件

函数重载碰到函数默认参数；(二义性)

☆☆类和对象：封装，继承，多态

封装: 权限，属性，方法

属性，方法

class 类名{访问权限： 属性 / 行为};

#include <iostream>using namespace std;const double PI=3.14;class Cricle{// 访问权限// 公共权限public:// 属性int r;// 行为double calculateZc(){return 2*PI*r;}};int main(){//对象Cricle c1;c1.r=10;cout<<c1.calculateZc()<<endl;// system("pause");return 0;}

#include <iostream>#include<string>using namespace std;class Student{public:string Name;int Id;void showStudent(){cout<<Name<<endl;}void setData(string name,int id){Name=name;Id=id;}// void setId(int id){//Id=id;// }};int main(){Student st1;st1.setData("string",1001);st1.showStudent();// system("pause");return 0;}

访问权限: public protected private

struct 和 class 区别 : 默认访问权限不同

#include <iostream>#include<string>using namespace std;class Test1{// 默认 私有 权限int a; };struct Test2{// 默认 公共 权限int a;};int main(){Test1 t1;Test2 t2;//t1.a=10;t2.a=10;// system("pause");return 0;}

成员属性设置为私有private

优点将所有成员属性设置为私有，可以自己控制读写权限；对于写权限，我们可以检测数据的有效性；(数据是否符合要求)

在类中可以让另一个类作为本来的成员；把不同的类放在不同的文件中；

对象的初始化和清理–构造函数(初始化)，析构函数(清理)

构造函数和析构函数

构造函数的分类及调用:两分类三调用

class Person{public:// 初始化：构造函数 // 创建对象时构造函数会自动调用，且每个对象仅调用一次// 没有返回值，不用写void；// 函数名与类名相同；// 构造函数可以有参也可以无参，可以发生重载Person(){cout<<"person默认构造函数的调用"<<endl;}//有参构造函数Person(int a){age=a;cout<<"person有参构造函数的调用"<<endl;}//拷贝构造函数Person(const Person &p){// 将传入的对象的所有属性拷贝过来age=p.age;cout<<"person拷贝构造函数的调用"<<endl;}// 清理：析构函数// 释放对象时调用// 没有返回值，不用写void；// 函数名与类名相同；// 析构函数无参，不可以发生重载~Person(){cout <<"person析构函数的调用"<<endl;}private:int age;};

// 1.括号法// Person p1; //默认构造函数调用// Person p2(10); // 有参构造函数// Person p3(p2); // 拷贝构造函数 // 注意事项// 调用默认函数时，不要加() Person p1();// 因为编译器会认为这是一个函数的声明 : void func();

// 2.显示法// Person p1;// Person p2 = Person(10);// Person p3 = Person(p2);// Person(10); 匿名对象 特点：当前行执行结束后，系统会立即回收掉匿名对象// 注意// 不要利用拷贝构造函数 初始化匿名对象 Person(p3)// 因为编译器会认为是对象声明 Person(p3) 等价于 Person p3;

拷贝构造函数调用时机

使用一个已经创建完毕的对象来初始化一个新对象

Person p3(p2);

值传递的方式给函数参数传值

void dowork(Person p){}void test02(){Person p;dowork(p); // 实参传给形参，形参创建对象}

以值方式返回局部对象

Person dowork2(){Person p1;return p1;}void test03(){Person p2=dowork2()}

存在问题(返回值优化)：vs和vscode运行结果不同

#include<iostream>#include<string>using namespace std;class Person {public:Person() {cout << "person默认构造函数的调用" << endl;}//有参构造函数Person(int a) {age = a;cout << "person有参构造函数的调用" << endl;}//拷贝构造函数Person(const Person &p) {// 将传入的对象的所有属性拷贝过来age = p.age;cout << "person拷贝构造函数的调用" << endl;}~Person() {cout << "person析构函数的调用" << endl;}private:int age;};Person dowork2() {Person p1;cout << &p1 << endl;return p1;}void test03() {Person p2 = dowork2();cout << &p2 << endl;}int main() {test03();system("pause");return 0;}

问题解析点击这里

构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数

1．默认构造函数(无参，函数体为空)

2．默认析构函数(无参，函数体为空)

3．默认拷贝构造函数(对属性进行值拷贝)

构造函数调用规则如下：

如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造

如果用户定义拷贝构造函数，c++不会再提供其他默认构造函数

拷贝构造函数《----有参构造函数《-----默认构造函数；

☆深拷贝与浅拷贝（释放内存）

深浅拷贝是面试经典问题，也是常见的一个坑

浅拷贝：简单的赋值拷贝操作

堆区的数据内存重复释放，解决方法可进行深拷贝操作，即重新定义一块内存

深拷贝：在堆区重新申请空间，进行拷贝操作

#include<iostream>using namespace std;class Person {public:Person() {cout << "person 的默认构造函数" << endl;}Person(int a, int height) {cout << "person 的有参构造函数" << endl;age = a;Height = new int(height);//堆区}Person(const Person &p) {cout << "person 的默认构造函数" << endl;age = p.age;// 浅拷贝// Height = p.Height; // 编译器默认实现// 深拷贝Height = new int(*p.Height);}~Person() {// if (Height != NULL) {delete Height;Height = NULL;}cout << "person 的析构函数" << endl;}int age;int *Height;};int main() {Person p1(18, 170);cout << "p1的年龄为" << p1.age << " p1的身高为" << *p1.Height << endl;Person p2(p1);cout << "p2的年龄为" << p2.age << " p2的身高为" << *p2.Height << endl;return 0;}

初始化列表（初始化属性）

Person(int a,int b,int c):A(a),B(b),C(c){}

#include<iostream>using namespace std;class Person{public ://初始化列表赋值Person(int a,int b,int c):A(a),B(b),C(c){}int A;int B;int C;};int main() {Person p(30,20,12);cout<<p.A<<endl;cout<<p.B<<endl;cout<<p.C<<endl;return 0;}

类对象作为类成员

当其他类对象作为本类成员时，构造对象时先构造类对象，再构造自身；析构时顺序相反；

#include<iostream>#include<string>using namespace std;class Phone{public:Phone(string name){types=name;}string types;};class Person{public:// Phone apple = types; // 隐式转换法Person(string name,string types):Name(name),apple(types){}string Name;Phone apple;};int main() {Person p("zhangsan","苹果");cout<<p.Name<<p.apple.types<<endl;return 0;}

静态成员（成员变量，成员函数，static）

静态成员分为：静态成员变量，静态成员函数

静态成员函数：

所有对象共享同一个函数静态成员函数只能访问静态成员变量

静态成员函数可以访问静态成员变量，但不可以访问非静态成员变量；

因为对于非静态成员变量而言，程序无法区分到底是哪个对象的属性

// 静态成员函数static void func(){cout<<"static void func"<<endl;}

// 通过对象访问Person p;p.func();// 通过类名访问Person::func();

静态成员变量：(共用的)

所有对象共享同一份数据在编译阶段分配内存类内声明，类外初始化

#include<iostream>#include<string>using namespace std;class Person{public:// 静态成员函数static void func(){a=100; // 静态成员函数可以访问静态成员变量cout<<"static void func"<<endl;}// 静态成员变量static int a;};int Person::a=0;int main() {// 通过对象访问Person p;p.func();// 通过类名访问Person::func();return 0;}