1.成员变量和成员函数分开存储

//1.在C++中，类内的成员变量和成员函数分开存储
//2.只有非静态成员变量才属于类的对象上

//空对象占用内存空间为：1
//C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占用内存的位置
//每个空对象也应该有一个独一无二的内存地址
代码：

/*C++对象模型和this指针*//*成员变量和成员函数分开存储*/
//1.在C++中，类内的成员变量和成员函数分开存储
//2.只有非静态成员变量才属于类的对象上class Person_zz
{public:void func(){}//非静态成员函数不属于类的对象static void func2(){}//静态成员函数不属于类的对象public:int m_A;//非静态成员变量属于类的对象static int m_B;//静态成员变量不属于类的对象
};
int Person_zz::m_B = 0;//静态成员变量类内声明类外初始化void test_zz1()
{Person_zz p;//空对象占用内存空间为：1//C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占用内存的位置//每个空对象也应该有一个独一无二的内存地址cout << "zize of p=" << sizeof(p) << endl;
}void test_zz2()
{Person_zz p;cout << "zize of p=" << sizeof(p) << endl;return;
}

main函数：

 /*C++对象模型和this指针*//*成员变量和成员函数分开存储*///test_zz1();test_zz2();

2.this指针概念

//每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码
//问题是：这一块代码是如何区分哪个对象调用自己的呢？
//C++通过提供特殊的对象指针-this指针，解决上述问题
//this指针指向被调用的成员函数所属的对象
//this指针是隐含每一个非静态成员函数内的一种指针
//this指针不需要定义，直接使用即可

//this指针的用途：
//1.当形参和成员变量同名时，可用this指针来区分
//2.在类的非静态成员函数中返回对象本身，可使用return *this；
代码：

/*this指针概念*/
//每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码
//问题是：这一块代码是如何区分哪个对象调用自己的呢？
//C++通过提供特殊的对象指针-this指针，解决上述问题
//this指针指向被调用的成员函数所属的对象
//this指针是隐含每一个非静态成员函数内的一种指针
//this指针不需要定义，直接使用即可//this指针的用途：//1.当形参和成员变量同名时，可用this指针来区分//2.在类的非静态成员函数中返回对象本身，可使用return *this；class Person_this
{public:Person_this(int age){//this指针指向被调用的成员函数所属的对象//本例是：this指向被调用的Person_this成员函数所属的对象p1，即this指向p1//Person_this::age = age;正确，用这样也对，说明age是Person_this作用域下的this->age = age;}Person_this& PersonAddAge(Person_this &p)  //返回p2的本体要用引用的方式 Person_this &，返回值类型一定要用引用//如果返回值类型是Person_this相当于是拷贝函数，会另外复制一份新的数据，输出将一直为20，无法实现累加{this->age += p.age;//自身的年龄=自身的年龄+p的年龄//this指向p2的指针，*this指向的就是p2这个对象的本体return *this;}
public:int age;
};//1.解决名称冲突
void test_this01()
{Person_this p1(18);cout << "p1的年龄为：" << p1.age << endl;
}//2.返回对象本身用*this
void test_this02()
{Person_this p1(10);Person_this p2(10);p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);cout << "p2的年龄为：" << p2.age << endl;
}

main函数：

 /*this指针概念*/test_this01();test_this02();

3.空指针访问成员函数

//C++中空指针也可以调用成员函数的，但是也要注意有没有用到this指针
//如果用到this指针，需要加以判断保证代码的健壮性
代码：

/*空指针访问成员函数*/
//C++中空指针也可以调用成员函数的，但是也要注意有没有用到this指针
//如果用到this指针，需要加以判断保证代码的健壮性class Person_k
{public:void showClassName(){cout << "this is Person class" << endl;return;}void showPersonAge(){//报错，因为传入的指针是NULL空指针，无法访问属性//纠正如下：if (this == NULL){return;}//提高代码的健壮性cout << "Person's age is:" << m_Age << endl;//此时的m_Age相当于this->m_Age，但是此时是空指针，无法访问其中的属性，是无中生有return;}public:int m_Age;
};void test_k01()
{Person_k *p = NULL;//空指针p->showClassName();//通过空指针调用成员函数p->showPersonAge();return;
}

main函数：

 /*空指针访问成员函数*/test_k01();

4.const修饰成员函数

//常函数：（只读状态）
//1.成员函数后加const后称这个函数为常函数 语法：返回值类型 函数名（） const {}
//2.常函数内不可以修改成员属性
//3.成员属性声明时加关键字mutable后，在常函数中依然可以修改

//常对象：
//1.声明对象前加const称该对象为常对象
//2.常对象只能调用常函数
代码：

/*const修饰成员函数*/
//常函数：（只读状态）//1.成员函数后加const后称这个函数为常函数  语法：返回值类型 函数名（） const  {}//2.常函数内不可以修改成员属性//3.成员属性声明时加关键字mutable后，在常函数中依然可以修改//常对象：//1.声明对象前加const称该对象为常对象//2.常对象只能调用常函数class Person_c
{public://this指针的本质是指针常量，相当于Person * const this;   指针的指向是不可以修改的//如果想让指针指向的值也不可以修改：  const Person * const this;  对应常函数如下：//在成员函数后面加const，修饰的是this指针，让指针指向的值也不可以修改void showPerson() const//相当于 const Person * const this;{this->m_B = 100;//m_A = 100;//m_A=100;相当于this->m_A=100;//this = NULL;//错误，this指针不可以修改指针的指向return;}void func(){return;}
public:int m_A;mutable int m_B;//特殊变量，即使在常函数中也可以修改这个值,加关键字mutable
};//常对象
void test_c()
{const Person_c p;//在对象前加const变为常对象//常对象也不允许修改指针指向的值//p.m_A = 100;p.m_B = 100;//m_B是特殊值，在常对象下也可以修改//常对象只能调用常函数p.showPerson();//p.func();//常对象不可以调用普通成员函数，因为普通成员函数可以修改属性return;
}

main函数：

 /*const修饰成员函数*/test_c();

5.友元

//在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术
//友元的目的就是让一个函数或者类访问另一个类中的私有成员
//友元的关键字为 friend
//友元的三种实现
//1.全局函数做友元
//2.类做友元
//3.成员函数做友元

5.1全局函数做友元

//goodGay全局函数是Building的好朋友，可以访问Building中的私有属性
//语法： friend 全局函数；  相当于   friend 返回值类型 函数名（参数列表）；

代码：

//全局函数做友元
//建筑物类
class Building_y
{//goodGay全局函数是Building的好朋友，可以访问Building中的私有属性//语法： friend 全局函数；  相当于   friend 返回值类型 函数名（参数列表）；friend void goodGay(Building_y *building);public:Building_y(){m_SittingRoom = "客厅";m_BedRoom = "卧室";return;}public:string m_SittingRoom;//客厅private:string m_BedRoom;//卧室
};//全局函数
void goodGay(Building_y *building)//指针传递
{cout << "好基友的全局函数正在访问：" << building->m_SittingRoom << endl;cout << "好基友的全局函数正在访问：" << building->m_BedRoom << endl;return;
}void test_y01()
{Building_y building;goodGay(&building);//通过&把地址传进去return;
}

main函数：

 //全局函数做友元test_y01();

5.2类做友元

//语法：friend class 类名；
代码：

//类做友元
//语法：friend class 类名；
class Building_yy;//告诉编译器一会儿我会写一个Building类,先别给我报错
class GoodGay
{public:void visit();//参观函数  访问Building中的属性GoodGay();
private:Building_yy * building;
};class Building_yy
{friend class GoodGay;//GoodGay类是本类的好朋友，可以访问本类的私有成员
public:Building_yy();
public:string m_SettingRoom;//客厅
private:string m_BedRoom;//卧室
};
//类外写成员函数
Building_yy::Building_yy()//加上作用域，告诉编译器是那个作用下的构造函数
{m_SettingRoom = "客厅";m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{//创建建筑物对象building = new Building_yy;
}
void GoodGay::visit()
{cout << "好基友类正在访问：" << building->m_SettingRoom << endl;cout << "好基友类正在访问：" << building->m_BedRoom << endl;
}
void test_yy01()
{GoodGay gg;gg.visit();return;
}

main函数：

 //类做友元test_yy01();

5.3成员函数做友元

//先声明Building类，再写GoodGAY类，最后写Building类，GoodGAY::visit要写到类外。否则会报错
//如果在GoodGAY类内写visit函数会报错，因为此时Building并未定义成员变量等，无法调用Building里的成员变量
//程序自上向下执行，声明定义顺序别弄错，visit函数要类外实现
代码：

//成员函数做友元
//先声明Building类，再写GoodGAY类，最后写Building类，GoodGAY::visit要写到类外。否则会报错
//如果在GoodGAY类内写visit函数会报错，因为此时Building并未定义成员变量等，无法调用Building里的成员变量
//程序自上向下执行，声明定义顺序别弄错，visit函数要类外实现
class Building;
class GoodGAY
{public:GoodGAY();void visit_yy01();//让visit_yy01函数可以访问Building中私有成员void visit_yy02();//让visit_yy02函数不可以访问Building中私有成员public:Building *building;
};class Building
{//告诉编译器，GoodGAY类下的visit_yy01成员函数作为本类的好朋友，可以访问私有成员friend void GoodGAY::visit_yy01();
public:Building();
public:string m_SettingRoom;//客厅
private:string m_BedRoom;//卧室
};
//类外实现成员函数
Building::Building()
{m_SettingRoom = "客厅";m_BedRoom = "卧室";
}
GoodGAY::GoodGAY()
{building = new Building;//用new在堆区创建一个指针，并用building来维护这个对象
}
void GoodGAY::visit_yy01()
{cout << "visit_yy01函数正在访问：" << building->m_SettingRoom << endl;cout << "visit_yy01函数正在访问：" << building->m_BedRoom << endl;}
void GoodGAY::visit_yy02()
{cout << "visit_yy02函数正在访问：" << building->m_SettingRoom << endl;//cout << "visit_yy02函数正在访问：" << building->m_BedRoom << endl;}
void test_yy()
{GoodGAY gg;gg.visit_yy01();gg.visit_yy02();
}

main函数：

 //成员函数做友元test_yy();

代码：

#include <iostream>
#include<string>
#include "point.h"
#include "circle2.h"using namespace std;//创建全局变量
int global_a = 10;
int global_b = 10;//const修饰的全局变量=全局常量
const int c_g_a = 10;
const int c_g_b = 10;//栈区
int * func()
{int a = 10;//局部变量 存放在栈区，栈区的数据在函数执行完后自动释放return &a;//返回局部变量的地址
}int * func2(int b)//形参数据也会放在栈区
{b = 100;int a = 10;//局部变量 存放在栈区，栈区的数据在函数执行完后自动释放return &a;//返回局部变量的地址
}//堆区
int * func3()
{//利用new关键字，可以将数据开辟到堆区//指针 本质也是局部变量，放在栈区，但是指针保存的数据是放在堆区int*p = new int(10);//new int(10)返回整型数据10的地址return p;
}//new
int * func4()
{//在堆区创建整型数据//new返回的是该数据类型的指针//语法：new 数据类型（变量值），这是创建一个变量int *p_new = new int(10);return p_new;
}void test01()
{int*p = func4();cout << *p << endl;//输出10cout << *p << endl;//10cout << *p << endl;//10//堆区的数据 由程序员管理开辟，程序员管理释放//如果想释放堆区的数据，用delete释放  语法：delete 指针变量名称；delete p;//cout << *p << endl;//内存已经被释放，再次访问就是非法操作，会报错
}//在堆区利用new开辟数组
void test02()
{//创建10个整型数据的数组，在堆区//语法： new 数据类型[数据值]，这是创建数据值个变量int *arr = new int[10];//10代表数组有10个元素for (int i = 0; i < 10; i++){arr[i] = i + 100;//给10个元素赋值：100~109}for (int i = 0; i < 10; i++){cout << arr[i] << endl;}//释放数组//语法：delete[] 指针变量名；delete[]arr;
}//引用做函数参数
//交换函数
//1.值传递
void mySwap01(int a, int b)
{int temp = a;a = b;b = temp;cout << "swap01\ta=" << a << "\tb=" << b << endl;//值传递形参发生改变return;
}//2.地址传递
void mySwap02(int *a, int *b)
{int temp = *a;*a = *b;*b = temp;return;
}//3.引用传递
void mySwap03(int &a,int &b)
{int temp = a;a = b;b = temp;return;
}/*引用做函数返回值*/
//语法：返回值类型 & 函数名称（参数列表) {函数体语句；return语句；}
//作用：引用是可以作为函数的返回值存在的
//1.不要返回局部变量的引用
int& test03()
{int a = 10;//局部变量存放在栈区return a;
}//2.函数的调用可以作为左值
int& test04()
{static int a = 10;//静态变量，存放在全局区，全局区上的数据在程序结束后系统释放return a;
}//引用的本质
//发现是引用，转换为 int* const ref = &a;
void func5(int& ref)
{ref = 100;// ref是引用，转换为*ref = 100 cout << "func5\tref=" << ref << endl;
} //打印数据函数
void showValue(int &val)
{val = 1000;cout << "value=" << val << endl;
}//打印数据函数2
void showValue2(const int &val)
{//val = 1000;//错误，不可修改cout << "value=" << val << endl;
}/*函数默认参数*/
int func6(int a, int b=20, int c=30)
{return a + b + c;
}int func7(int a, int b=1, int c=2 )  //1.如果某个位置已经有了默认参数，那么从这个位置往后都必须有默认值
{return a + b + c;
}//2.如果函数声明有默认参数，函数实现就不能有默认参数
//函数声明和函数实现只能有一个有默认参数,两者任选一个给默认值就可以
//int func8(int a=10, int b=20);//函数声明int func8(int a=10, int b = 20)//函数实现
{return a + b ;
}/*占位参数*/
//占位参数还可以有默认值 比如：void func9(int a,int =10)
void func9(int a,int)
{cout << "this is func9" << endl;
}/*函数重载*/
//可以让函数名相同，提高复用性
//函数重载满足条件：
//1.同一个作用域下
//2.函数名称相同
//3.函数参数类型不同或者个数不同或者顺序不同void funct()
{cout << "funct的调用" << endl;
}void funct(int a)
{cout << "funct(int a)的调用" << endl;
}void funct(double a)
{cout << "funct(double a)的调用" << endl;
}void funct(int a, double b)
{cout << "funct(int a,double b)的调用：" << endl;
}void funct(double a, int b)
{cout << "funct(double a, int b)的调用：" << endl;
}//注意：函数的返回值不可以作为函数重载的条件  int跟void返回值不同，不可以作为重载的条件
//int funct(double a, int b)
//{//  cout << "funct(double a, int b)的调用：" << endl;
//}//函数重载注意事项
//1.引用作为重载条件
void fun(int &a)
{cout << "fun(int &a)调用" << endl;
}void fun(const int &a)
{cout << "fun(const int &a)调用" << endl;
}
//2.函数重载碰到函数默认参数
void fun2(int a)
{cout << "fun2(int a)的调用" << endl;
}void fun2(int a,int b=10)
{cout << "fun2(int a)的调用" << endl;
}/*类和对象*//*封装*///将属性和行为作为一个整体，表现生活中的事物
//语法：class 类名 { 访问权限： 属性；行为；}；//圆周率
const double PI = 3.14;//设计一个圆类，求圆的周长
//圆的周长公式：2 * PI *半径
//class 代表设计一个类，类后面紧跟着的是类名称
class Circle
{//访问权限
public://公共权限//属性int m_r;//半径//行为，通常用函数来表示//获取圆的周长double calculateZC(){return 2 * PI*m_r;}};//设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
//设计学生类
class Student
{//公共权限
public://属性string m_Name;//姓名int m_ID;//学号//行为//显示姓名和学号void showStudent(){cout << "姓名："<< m_Name << "\t学号：" << m_ID << endl;}//给姓名赋值void setName(string name){m_Name = name;}//给学号赋值void setID(int ID){m_ID = ID;}
};//将属性和行为加以权限控制//public 公共权限   成员在类内可以访问,类外也可以访问//protected 保护权限   成员在类内可以访问，类外不可以访问  儿子也可以访问父亲中的保护内容//private 私有权限   成员在类内可以访问，类外不可以访问   儿子不可以访问父亲中的私有内容class Person
{public://公共权限//姓名string m_Name;protected://保护权限//汽车string m_Car;private://私有权限//银行卡密码int m_Password;public:void func(){m_Name = "张三";m_Car = "拖拉机";m_Password = 123456;}};/*struct和class区别*///struct默认权限为公共//class默认权限为私有
class C1
{int m_A;//默认权限是私有
};
struct C2
{int m_A;//默认权限是公共
};/*成员属性设置为私有*/
//优点1：将所有成员属性设置为私有，可以自己控制读写权限
//优点2：对于写权限，我们可以检测数据的有效性//设计人的类
class Person1
{public://写姓名=设置姓名void setName(string name){m_Name = name;}//读姓名=获取姓名string getName(){return m_Name;}//获取年龄  可读可写  如果想修改（年龄的范围必须是0-150之间）int getAge(){//m_Age = 0;//初始化为0岁return m_Age;}//设置年龄void setAge(int age){if (age < 0 || age>150){m_Age = 0;cout << "你这个老妖精！" << endl;return;//没有return的话会往下执行m_Age=age赋值操作，有return以后直接退出}m_Age = age;}//设置情人  只写void setLover(string lover){m_Lover = lover;}private://姓名  可读可写string m_Name;//年龄  可读可写  如果想修改（年龄的范围必须是0-150之间）int m_Age;//情人  只写string m_Lover;
};/*设计长方体类*/
//1.创建长方体类
//2.设计属性
//3.设计行为 获取长方体面积和体积
//4.分别利用全局函数和成员函数 判断两个长方体是否相等
class Cube
{public://设置长void setL(int l){m_L = l;}//获取长int getL(){return m_L;}//设置宽void setW(int w){m_W = w;}//获取宽int getW(){return m_W;}//设置高void setH(int h){m_H = h;}//获取高int getH(){return m_H;}//获取长方体面积int calculateS(){return 2 * m_L*m_H + 2 * m_H*m_W + 2 * m_W*m_L;}//获取长方体体积int calculateV(){return m_H * m_L*m_W;}//利用成员函数判断两个长方体是否相等bool isSameByClass(Cube &cube){//用getL()与cube.getL()判断或者m_L与cube.getL()判断if (getL() == cube.getL() && m_W == cube.getW() && m_H == cube.getH()){return true;}elsereturn false;}private:int m_L;//长int m_W;//宽int m_H;//高
};//利用全局函数判断两个长方体是否相等
bool isSame(Cube &cube1, Cube &cube2)
{if (cube1.getL() == cube2.getL() && cube1.getW() == cube2.getW() && cube1.getH() == cube2.getH()){return true;}elsereturn false;
}/*点和圆的关系案例*/
//根据点到圆心的距离 与 半径作比较来判断点类
//class Point
//{//public:
//  //设置x
//  void setX(int x)
//  {//      m_X = x;
//      //return;
//  }
//  //获取x
//  int getX()
//  {//      return m_X;
//  }
//  //设置y
//  void setY(int y)
//  {//      m_Y = y;
//      //return;
//  }
//  //获取y
//  int getY()
//  {//      return m_Y;
//  }
//
//private:
//  int m_X;
//  int m_Y;
//};圆类
//class Circle2
//{//public:
//  //设置半径
//  void setR(int r)
//  {//      m_R = r;
//      //return;
//  }
//  //获取半径
//  int getR()
//  {//      return m_R;
//  }
//  //设置圆心
//  void setCenter(Point center)
//  {//      m_Center = center;
//      //return;
//  }
//  //获取圆心
//  Point getCenter()
//  {//      return m_Center;
//  }
//
//private:
//  int m_R;//半径
//
//  //可以用一个点类来表示
//  //int m_X;//x坐标
//  //int m_Y;//y坐标
//  //圆心
//  //在类中可以让另一个类作为本类的成员
//  Point m_Center;
//};//判断点和圆的关系
void isInCircle(Circle2 &c, Point &p)
{//计算两点之间距离的平方int distance = (c.getCenter().getX() - p.getX()) * (c.getCenter().getX()-p.getX()) + (c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());//计算半径的平方int rDistance = c.getR() * c.getR();//判断关系if (distance == rDistance){cout << "点在圆上" << endl;}else if (distance > rDistance){cout << "点在圆外" << endl;}else{cout << "点在圆内" << endl;}
}/*对象的初始化和清理*///生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全
//C++中的面向对象来源于生活，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置。/*构造函数和析构函数*/
//一个对象或者变量没有初始状态，对其使用后果是未知
//同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题//c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。
//对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供
//编译器提供的构造函数和析构函数是空实现。//构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
//析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。//构造函数语法： 类名（）{}
//1. 构造函数，没有返回值也不写void
//2. 函数名称与类名相同
//3. 构造函数可以有参数，因此可以发生重载
//4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次//析构函数语法：  ~类名（）{}
//1. 析构函数，没有返回值也不写void
//2. 函数名称与类名相同,在名称前加上符号 ~
//3. 析构函数不可以有参数，因此不可以发生重载
//4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次class Person_gz
{public://1.构造函数//没有返回值，不用写void//函数名与类名相同//构造函数有参数，可以发生重载//创建对象的同时，构造函数会自动调用，而且只调用一次Person_gz(){cout << "Person构造函数的调用" << endl;}//2.析构函数//没有返回值，不用写void//函数名与类名相同，在名称前加~//析构函数不可以有参数，不可以发生重载//对象在销毁前会自动调用析构函数，而且只会调用一次~Person_gz(){cout << "Person析构函数的调用" << endl;}};//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构函数
void test_gz()
{Person_gz person_gz; //在栈上的数据，test_gz执行完毕后，会释放这个对象
}/*构造函数的分类及调用*/
//按参数分为： 有参构造和无参构造
//按类型分为： 普通构造和拷贝构造
//三种调用方式：
//括号法
//显示法
//隐式转换法//1.按照参数分类   无参构造（=默认构造）和有参构造
//2.按照类型分类   普通构造   和拷贝构造
class Person_fl
{public://构造函数Person_fl() //无参构造函数=默认构造函数{cout << "Person_fl的无参构造函数调用" << endl;}Person_fl(int a)//有参构造函数{age = a;cout << "Person_fl的有参构造函数调用" << endl;}//拷贝构造函数//拷贝函数语法： 类名（const 类名 & 引用名称){ }Person_fl(const Person_fl &p) {//将传入的人身上的所有属性，拷贝到我身上age = p.age;cout << "Person_fl的拷贝函数调用" << endl;}//析构函数~Person_fl(){cout << "Person_fl的析构函数调用" << endl;}public:int age;
};void test_fl()
{//1.括号法Person_fl person_fl1; //默认构造函数的调用,不要加()Person_fl person_fl2(10);//有参构造函数的调用Person_fl person_fl3(person_fl2); //拷贝构造函数的调用//注意事项//调用默认构造函数时候，不要加()//因为加了括号以后，编译器会认为是一个函数的声明，比如 Person p1();与void func();所以不会认为是在创建对象//Person_fl person_fl1(); //错误，不要加（），会认为是函数声明cout << "person_fl2的年龄为：" << person_fl2.age << endl;cout << "person_fl3的年龄为" << person_fl3.age << endl;//2.显示法Person_fl person_fl4;Person_fl person_fl5 = Person_fl(10);//有参构造， Person_fl(10)是匿名对象，当前行执行结束后，系统会立即回收掉匿名对象Person_fl person_fl6 = Person_fl(person_fl5);//拷贝构造//注意事项//不要利用拷贝函数来初始化匿名对象//Person_fl(person_fl5); //错误，编译器会认为Person_fl(person_fl5);等价于Person_fl person_fl5;，编译器会认为是对象声明，会报重定义错误Person_fl(10);// Person_fl(10)是匿名对象，当前行执行结束后，系统会立即回收掉匿名对象即立即执行析构函数,执行完析构函数后再往下执行cout << "aaaa" << endl;//3.隐式转换法Person_fl person_fl7 = 10;//相当于Person_fl person_fl7 = person_fl7(10);   有参构造Person_fl person_fl8 = person_fl7;//拷贝构造}/*拷贝构造函数调用时机*/
//C++中拷贝构造函数调用时机通常有三种情况
//使用一个已经创建完毕的对象来初始化一个新对象
//值传递的方式给函数参数传值
//以值方式返回局部对象class Person_kb
{public:Person_kb(){cout << "Person_kb默认构造函数调用" << endl;}~Person_kb(){cout << "Person_kb析构函数调用" << endl;}Person_kb(int age){cout << "Person_kb有参构造函数调用" << endl;m_Age = age;}Person_kb(const Person_kb &p){cout << "Person_kb拷贝构造函数调用" << endl;m_Age = p.m_Age;}public:int m_Age;
};//1.使用一个已经创建完毕的对象来初始化一个新对象
void test_kb1()
{Person_kb person_kb1(20);Person_kb person_kb2(person_kb1);cout << "person_kb2的年龄为：" << person_kb2.m_Age << endl;return;
}//2.值传递的方式给函数参数传值,值传递形参不会影响实参
void doWork(Person_kb p)
{return;
}void test_kb2()
{Person_kb person_kb3;//无参构造函数doWork(person_kb3);//拷贝构造函数return;
}//3.值方式返回局部对象
Person_kb doWork2()
{Person_kb p1; //默认构造函数cout << (int*)&p1 << endl;return p1;
}void test_kb3()
{Person_kb person_kb4 = doWork2(); //拷贝构造函数，相当于Person_kb person_kb4=p1的副本cout << (int*)&person_kb4 << endl;return;
}/*构造函数调用规则*/
//默认情况下，c++编译器至少给一个类添加3个函数
//1．默认构造函数(无参，函数体为空)
//2．默认析构函数(无参，函数体为空)
//3．默认拷贝构造函数，对属性进行值拷贝//构造函数调用规则如下：
//如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
//如果用户定义拷贝构造函数，c++不会再提供其他构造函数class Person_gzz
{public:Person_gzz(){cout << "person_gzz的默认构造函数" << endl;}~Person_gzz(){cout << "Person_gzz的析构函数" << endl;}Person_gzz(int age){cout << "Person_gzz的有参构造函数" << endl;m_Age = age;}/*Person_gzz(const Person_gzz &p){cout << "Person_gzz的拷贝构造函数" << endl;m_Age = p.m_Age;}*/  //如果用户没有定义拷贝构造函数，编译器会进行值拷贝m.Age=p.m.Age;public:int m_Age;
};void test_gzz()
{Person_gzz person_gzz1;//默认构造函数person_gzz1.m_Age = 18;Person_gzz person_gzz2(person_gzz1);//拷贝构造函数cout << "person_gzz2的年龄为:" << person_gzz2.m_Age << endl;return;
}//如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
//如果用户定义拷贝构造函数，c++不会再提供其他构造函数
void test_gzz2()
{Person_gzz person_gzz3(28);Person_gzz person_gzz4(person_gzz3);//编译器提供默认的拷贝构造函数cout << "person_gzz4的年龄为：" << person_gzz4.m_Age << endl;return;
}/*深拷贝与浅拷贝*/
//浅拷贝：简单的赋值拷贝操作（编译器提供的拷贝构造函数）
//深拷贝：在堆区重新申请空间，进行拷贝操作
class Person_sq
{public:Person_sq(){cout << "Person_sq的默认构造函数" << endl;}~Person_sq(){//析构代码，将堆区开辟的数据做释放操作//浅拷贝带来的问题是堆区的内存重复释放，会崩溃if (m_Height != NULL){delete m_Height;m_Height = NULL;//置空操作，防止野指针出现}cout << "Person_sq的析构函数" << endl;}Person_sq(int age, int height){m_Age = age;m_Height = new int(height);cout << "Person_sq的有参构造函数" << endl;}//自己实现拷贝构造函数，解决浅拷贝带来的问题//如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题Person_sq(const Person_sq &p){cout << "Person_sq拷贝构造函数的调用" << endl;m_Age = p.m_Age;//m_Height = p.m_Height;//编译器默认实现的就是这行代码//深拷贝操作m_Height = new int(*p.m_Height);//在堆区利用new重新开辟一个内存空间，让m_Height重新指向高度值}public:int m_Age;//年龄int *m_Height;//审稿
};void test_sq1()
{Person_sq  person_sq1(200,180);cout << "person_sq1的年龄为：" << person_sq1.m_Age << "\tperson_sq1的身高为：" << *person_sq1.m_Height << endl;Person_sq person_sq2(person_sq1);//数据先进后出，因此person_sq2先被析构cout << "person_sq2的年龄为：" << person_sq2.m_Age << "\tperson_sq2的身高为：" << *person_sq2.m_Height << endl;return;
}/*初始化列表*/
//作用：C++提供了初始化列表语法，用来初始化属性
//语法：构造函数（）：属性1（值1），属性2（值2）...{}
//构造函数（变量类型1 变量名1，变量类型2 变量名2...):属性1（变量名1），属性2（变量名2）...{}
class Person_csh
{public:传统初始化操作//Person_csh(int a, int b, int c)//{//    m_A = a;// m_B = b;// m_C = c;//}//初始化列表来初始化属性/*Person_csh() :m_A(10), m_B(20), m_C(30){}*/Person_csh(int a, int b, int c) :m_A(a), m_B(b), m_C(c){}public:int m_A;int m_B;int m_C;
};void test_csh()
{Person_csh person_csh(10, 20, 30);//Person_csh person_csh;cout << "m_A=" << person_csh.m_A << "\tm_B=" << person_csh.m_B << "\tm_C=" << person_csh.m_C << endl;return;
}/*类对象作为类成员*/
//C++类中的成员可以是另一个类的对象，我们成该成员为对象成员
//当其他类对象作为本类成员，本类对象会先构造其他类对象再构造自身，即本例是先构造Phone，再构造Person
//先进后出，析构函数正好相反，即先析构自身再析构其他类class A
{};
class B
{A a;//实例化对象A
};
//B类中有对象A作为成员，A为对象成员//手机类
class Phone
{public:Phone(string pName){m_Pname = pName;cout << "Phone的构造函数调用" << endl;}~Phone(){cout << "Phone的析构函数调用" << endl;}public://品牌名称string m_Pname;
};//人类
class Person_l
{public://隐式转换法  m_Phone(pName)相当于 Phone m_Phone = pNamePerson_l(string name, string pName):m_Name(name),m_Phone(pName) //此时的m_Phone(pName)相当于 Phone m_Phone=pName{cout << "Person_l的构造函数调用" << endl;}~Person_l(){cout << "Person_l的析构函数调用" << endl;}public://姓名string m_Name;//手机Phone m_Phone;
};void test_l()
{Person_l p("张三", "苹果");cout << p.m_Name << "拿着" << p.m_Phone.m_Pname << "品牌的手机" << endl;return;
}/*静态成员*/
//静态成员就是在成员变量和成员函数前加上关键字static，成为静态成员
//静态成员分类：//静态成员变量//1.所有对象共用同一份数据//2.在编译阶段分配内存（全局区）//3.类内声明，类外初始化//静态成员函数//1.所有对象共享同一个函数//2.静态成员函数只能访问静态成员变量class Person_jt
{public:public://所有对象都共享同一份数据//编译阶段就分配内存//类内声明，类外初始化操作static int m_A;//类内声明//静态成员变量也是有访问权限的
private:static int m_B;};
int Person_jt::m_A = 100;//类外初始化操作
int Person_jt::m_B = 300;void test_jt()
{Person_jt p;//100cout << p.m_A << endl;Person_jt p2;p2.m_A = 200;//所有对象共享同一份数据//200cout << p.m_A << endl;
}void test_jt2()
{//静态成员变量  不属于某个对象上 所有对象都共享同一份数据//因此静态成员变量有两种访问方式//1.通过对象进行访问Person_jt p;cout << "通过对象进行访问：" << endl;cout << p.m_A << endl;//2.通过类名进行访问cout << "通过类名进行访问：" << endl;cout << Person_jt::m_A << endl;//cout << Person_jt::m_B << endl; //错误，私有权限访问不到}//静态成员函数
//所有对象共享同一个函数
//静态成员函数只能访问静态成员变量
class Person_j
{public:static void func(){m_A = 1000;//静态成员函数可以访问静态成员变量//m_B = 200;//错误，静态成员函数不可以访问非静态成员变量，因为无法区分到底是哪个对象的m_B属性cout << "static void func调用" << endl;}public:static int m_A;//静态成员变量int m_B;//非静态成员变量//静态成员函数也是有访问权限的
private:static void func2(){cout << "static void func2函数调用" << endl;}};
int Person_j::m_A = 0;//有两种访问方式
void test_j()
{//1.通过对象访问Person_j p;p.func();//2.通过类名访问Person_j::func();//Person_j::func2();  //错误，类外无法访问私有静态成员函数
}/*C++对象模型和this指针*//*成员变量和成员函数分开存储*/
//1.在C++中，类内的成员变量和成员函数分开存储
//2.只有非静态成员变量才属于类的对象上class Person_zz
{public:void func(){}//非静态成员函数不属于类的对象static void func2(){}//静态成员函数不属于类的对象public:int m_A;//非静态成员变量属于类的对象static int m_B;//静态成员变量不属于类的对象
};
int Person_zz::m_B = 0;//静态成员变量类内声明类外初始化void test_zz1()
{Person_zz p;//空对象占用内存空间为：1//C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占用内存的位置//每个空对象也应该有一个独一无二的内存地址cout << "zize of p=" << sizeof(p) << endl;
}void test_zz2()
{Person_zz p;cout << "zize of p=" << sizeof(p) << endl;return;
}/*this指针概念*/
//每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码
//问题是：这一块代码是如何区分哪个对象调用自己的呢？
//C++通过提供特殊的对象指针-this指针，解决上述问题
//this指针指向被调用的成员函数所属的对象
//this指针是隐含每一个非静态成员函数内的一种指针
//this指针不需要定义，直接使用即可//this指针的用途：//1.当形参和成员变量同名时，可用this指针来区分//2.在类的非静态成员函数中返回对象本身，可使用return *this；class Person_this
{public:Person_this(int age){//this指针指向被调用的成员函数所属的对象//本例是：this指向被调用的Person_this成员函数所属的对象p1，即this指向p1//Person_this::age = age;正确，用这样也对，说明age是Person_this作用域下的this->age = age;}Person_this& PersonAddAge(Person_this &p)  //返回p2的本体要用引用的方式 Person_this &，返回值类型一定要用引用//如果返回值类型是Person_this相当于是拷贝函数，会另外复制一份新的数据，输出将一直为20，无法实现累加{this->age += p.age;//自身的年龄=自身的年龄+p的年龄//this指向p2的指针，*this指向的就是p2这个对象的本体return *this;}
public:int age;
};//1.解决名称冲突
void test_this01()
{Person_this p1(18);cout << "p1的年龄为：" << p1.age << endl;
}//2.返回对象本身用*this
void test_this02()
{Person_this p1(10);Person_this p2(10);p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);cout << "p2的年龄为：" << p2.age << endl;
}/*空指针访问成员函数*/
//C++中空指针也可以调用成员函数的，但是也要注意有没有用到this指针
//如果用到this指针，需要加以判断保证代码的健壮性class Person_k
{public:void showClassName(){cout << "this is Person class" << endl;return;}void showPersonAge(){//报错，因为传入的指针是NULL空指针，无法访问属性//纠正如下：if (this == NULL){return;}//提高代码的健壮性cout << "Person's age is:" << m_Age << endl;//此时的m_Age相当于this->m_Age，但是此时是空指针，无法访问其中的属性，是无中生有return;}public:int m_Age;
};void test_k01()
{Person_k *p = NULL;//空指针p->showClassName();//通过空指针调用成员函数p->showPersonAge();return;
}/*const修饰成员函数*/
//常函数：（只读状态）//1.成员函数后加const后称这个函数为常函数  语法：返回值类型 函数名（） const  {}//2.常函数内不可以修改成员属性//3.成员属性声明时加关键字mutable后，在常函数中依然可以修改//常对象：//1.声明对象前加const称该对象为常对象//2.常对象只能调用常函数class Person_c
{public://this指针的本质是指针常量，相当于Person * const this;   指针的指向是不可以修改的//如果想让指针指向的值也不可以修改：  const Person * const this;  对应常函数如下：//在成员函数后面加const，修饰的是this指针，让指针指向的值也不可以修改void showPerson() const//相当于 const Person * const this;{this->m_B = 100;//m_A = 100;//m_A=100;相当于this->m_A=100;//this = NULL;//错误，this指针不可以修改指针的指向return;}void func(){return;}
public:int m_A;mutable int m_B;//特殊变量，即使在常函数中也可以修改这个值,加关键字mutable
};//常对象
void test_c()
{const Person_c p;//在对象前加const变为常对象//常对象也不允许修改指针指向的值//p.m_A = 100;p.m_B = 100;//m_B是特殊值，在常对象下也可以修改//常对象只能调用常函数p.showPerson();//p.func();//常对象不可以调用普通成员函数，因为普通成员函数可以修改属性return;
}/*友元*/
//在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术
//友元的目的就是让一个函数或者类访问另一个类中的私有成员
//友元的关键字为 friend
//友元的三种实现//1.全局函数做友元//2.类做友元//3.成员函数做友元//全局函数做友元
//建筑物类
class Building_y
{//goodGay全局函数是Building的好朋友，可以访问Building中的私有属性//语法： friend 全局函数；  相当于   friend 返回值类型 函数名（参数列表）；friend void goodGay(Building_y *building);public:Building_y(){m_SittingRoom = "客厅";m_BedRoom = "卧室";return;}public:string m_SittingRoom;//客厅private:string m_BedRoom;//卧室
};//全局函数
void goodGay(Building_y *building)//指针传递
{cout << "好基友的全局函数正在访问：" << building->m_SittingRoom << endl;cout << "好基友的全局函数正在访问：" << building->m_BedRoom << endl;return;
}void test_y01()
{Building_y building;goodGay(&building);//通过&把地址传进去return;
}//类做友元
//语法：friend class 类名；
class Building_yy;//告诉编译器一会儿我会写一个Building类,先别给我报错
class GoodGay
{public:void visit();//参观函数  访问Building中的属性GoodGay();
private:Building_yy * building;
};class Building_yy
{friend class GoodGay;//GoodGay类是本类的好朋友，可以访问本类的私有成员
public:Building_yy();
public:string m_SettingRoom;//客厅
private:string m_BedRoom;//卧室
};
//类外写成员函数
Building_yy::Building_yy()//加上作用域，告诉编译器是那个作用下的构造函数
{m_SettingRoom = "客厅";m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{//创建建筑物对象building = new Building_yy;
}
void GoodGay::visit()
{cout << "好基友类正在访问：" << building->m_SettingRoom << endl;cout << "好基友类正在访问：" << building->m_BedRoom << endl;
}
void test_yy01()
{GoodGay gg;gg.visit();return;
}//成员函数做友元
//先声明Building类，再写GoodGAY类，最后写Building类，GoodGAY::visit要写到类外。否则会报错
//如果在GoodGAY类内写visit函数会报错，因为此时Building并未定义成员变量等，无法调用Building里的成员变量
//程序自上向下执行，声明定义顺序别弄错，visit函数要类外实现
class Building;
class GoodGAY
{public:GoodGAY();void visit_yy01();//让visit_yy01函数可以访问Building中私有成员void visit_yy02();//让visit_yy02函数不可以访问Building中私有成员public:Building *building;
};class Building
{//告诉编译器，GoodGAY类下的visit_yy01成员函数作为本类的好朋友，可以访问私有成员friend void GoodGAY::visit_yy01();
public:Building();
public:string m_SettingRoom;//客厅
private:string m_BedRoom;//卧室
};
//类外实现成员函数
Building::Building()
{m_SettingRoom = "客厅";m_BedRoom = "卧室";
}
GoodGAY::GoodGAY()
{building = new Building;//用new在堆区创建一个指针，并用building来维护这个对象
}
void GoodGAY::visit_yy01()
{cout << "visit_yy01函数正在访问：" << building->m_SettingRoom << endl;cout << "visit_yy01函数正在访问：" << building->m_BedRoom << endl;}
void GoodGAY::visit_yy02()
{cout << "visit_yy02函数正在访问：" << building->m_SettingRoom << endl;//cout << "visit_yy02函数正在访问：" << building->m_BedRoom << endl;}
void test_yy()
{GoodGAY gg;gg.visit_yy01();gg.visit_yy02();
}
int main()
{/*友元*///全局函数做友元test_y01();//类做友元test_yy01();//成员函数做友元test_yy();/*const修饰成员函数*/test_c();/*空指针访问成员函数*/test_k01();/*this指针概念*/test_this01();test_this02();/*C++对象模型和this指针*//*成员变量和成员函数分开存储*///test_zz1();test_zz2();/*静态成员*///test_jt();test_jt2();test_j();/*类对象作为类成员*/test_l();/*初始化列表*/test_csh();/*深拷贝与浅拷贝*/test_sq1();/*构造函数调用规则*/test_gzz();test_gzz2();/*拷贝构造函数调用时机*/test_kb1();test_kb2();test_kb3();/*构造函数的分类及调用*/test_fl();/*对象的初始化和清理*///生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全 //C++中的面向对象来源于生活，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置。/*构造函数和析构函数*/test_gz();//创建对象的时候，构造函数会自动调用，不需要手动调用，而且调用只有一次Person_gz person_gz2; //此时并不会释放，因此不会调用析构函数/*判断点和圆的关系*///创建圆Circle2 circle2;circle2.setR(10);Point center;center.setX(10);center.setY(0);circle2.setCenter(center);//创建点Point point;point.setX(10);point.setY(10);//判断点和圆的关系isInCircle(circle2, point);/*设计长方体类*///实例化对象  创建长方体Cube cube1;cube1.setL(10);cube1.setH(10);cube1.setW(10);cout << "cube1的面积为：" << cube1.calculateS() << endl;cout << "cube1的体积为：" << cube1.calculateV() << endl;//创建第二个长方体Cube cube2;cube2.setL(10);cube2.setH(10);cube2.setW(10);//判断两个长方体是否相等//利用全局函数判断bool result1 = isSame(cube1, cube2);if (result1){cout << "两个相等" << endl;}else{cout << "两个不相等" << endl;}//利用成员函数判断bool result2 = cube1.isSameByClass(cube2);if (result2){cout << "两个相等 " << endl;}else{cout << "两个不相等    " << endl;}/*成员属性设置为私有*///优点1：将所有成员属性设置为私有，可以自己控制读写权限//优点2：对于写权限，我们可以检测数据的有效性Person1 pp1;pp1.setName("张六");cout << "姓名为：" << pp1.getName() << endl;pp1.setAge(1000);cout << "年龄为：" << pp1.getAge() << endl;pp1.setLover("王五");/*struct和class区别*///struct默认权限为公共//class默认权限为私有C1 cc1;//cc1.m_A = 100;//错误，class默认权限为私有，类外不可以访问C2 c2;c2.m_A = 100;//正确，struct默认权限为公共/*类和对象*///c++面向对象的三大特性为：封装、继承、多态//C++认为万事万物都皆为对象，对象上有其属性和行为//例如：//人可以作为对象，属性有姓名、年龄、身高、体重...，行为有走、跑、跳、吃饭、唱歌...//车也可以作为对象，属性有轮胎、方向盘、车灯..., 行为有载人、放音乐、放空调...//具有相同性质的 == 对象 == ，我们可以抽象称为 == 类 == ，人属于人类，车属于车类/*封装*///封装的意义：//将属性和行为作为一个整体，表现生活中的事物//将属性和行为加以权限控制//将属性和行为作为一个整体，表现生活中的事物//语法：class 类名 { 访问权限： 属性；行为；}；//类中的属性和成员，统一称为成员//属性=成员属性=成员变量//行为=成员函数=成员方法//设计一个圆类，求圆的周长//圆的周长公式：2 * PI *半径//实例化：通过一个类创建一个对象的过程//通过圆类创建具体的圆（对象）//语法：类名称 对象名称；Circle c1;//给圆对象的属性进行赋值c1.m_r = 10;cout << "圆的周长为：" << c1.calculateZC() << endl;//设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号//创建一个具体的学生   实例化对象Student s1;//给s1对象进行属性赋值操作s1.m_Name = "张三";s1.m_ID = 1;//显示学生信息s1.showStudent();Student s2;s2.setName("李四");s2.setID(2);s2.showStudent();//将属性和行为加以权限控制//public 公共权限//protected 保护权限//private 私有权限//实例化具体对象Person p1;p1.m_Name = "王五";//p1.m_Car = "奔驰"; //错误，保护权限内容，在类外访问不到//p1.m_Password = 123;//错误，私有权限内容，类外访问不到/*内存分区模型*///内存大方向分为四个区域//代码区：存放函数体的二进制代码，由操作系统进行管理//全局区：存放全局变量和静态变量以及常量//栈区：由编译器自动分配释放，存放函数的参数值，局部变量等//堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收/*程序运行之前：代码区，全局区*///代码区：存放CPU执行的机器指令//代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可//代码区是只读的，使其只读的原因是防止程序意外地修改它的指令//全局区包括：全局变量、静态变量、全局常量、字符串常量//全局区的数据在程序结束后由操作系统释放//创建普通局部变量int a1 = 10;int b1 = 10;cout << "局部变量a1的地址为：" << (int)&a1 << endl;cout << "局部变量b1的地址为：" << (int)&b1 << endl;//输出定义的全局变量cout << "全局变量global_a的地址为：" << (int)&global_a << endl;cout << "全局变量global_b的地址为：" << (int)&global_b << endl;//创建静态变量,在普通变量前加static就属于静态变量//语法：static 数据类型 变量名称；static int static_a = 10;static int static_b = 10;cout << "静态变量static_a的地址为：" << (int)&static_a << endl;cout << "静态变量static_b的地址为：" << (int)&static_b << endl;//常量//字符串常量  语法："..."cout << "字符串常量的地址为：" << (int)&"hello world" << endl;//const修饰的变量：修饰全局变量、修饰局部变量//const修饰的全局变量cout << "全局常量c_g_a的地址为：" << (int)&c_g_a << endl;cout << "全局常量c_g_b的地址为：" << (int)&c_g_b << endl;//const修饰的局部变量//c-const，g-global，l-localconst int c_l_a = 10;const int c_l_b = 10;cout << "局部常量c_l_a的地址为：" << (int)&c_l_a << endl;cout << "局部常量c_l_b的地址为：" << (int)&c_l_b << endl;//全局常量、全局变量、静态变量和字符串常量放在全局区，局部常量和局部变量不在全局区//总结//C++中在程序运行前分为全局区和代码区 //代码区特点是共享和只读 //全局区中存放全局变量、静态变量、常量 //常量区中存放const修饰的全局常量和字符串常量/*程序运行后：栈区和堆区*///栈区：由编译器自动分配释放，存放函数的参数值，局部变量等//注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放//接收func函数的返回值int *p = func();cout << *p << endl;//输出10 //第一次可以打印正确的数字，是因为编译器做了一次保留cout << *p << endl;//输出乱码 //第二次这个数据就不再保留//堆区;由程序员分配释放，若程序员不释放，程序结束时由操作系统回收//在C++中主要利用new在堆区开辟内存int *p_dq = func3();cout << *p_dq << endl;//输出10cout << *p_dq << endl;//输出10/*new操作符*///利用new在堆区开辟数据//语法：new 数据类型//利用new创建的数据，会返回该数据对应类型的指针//堆区开辟的数据，由程序员手动开辟，手动释放，释放利用delete进行test01();test02();/*引用*///引用：给变量起别名//语法：数据类型 &别名=原名；int a_yy = 10;int &b_yy = a_yy;cout << "a=" << a_yy << endl;//输出10cout << "b=" << b_yy << endl;//10b_yy = 100;//通过修改b_yy,此时a_yy、b_yy都修改为100cout << "a=" << a_yy << endl;//输出100cout << "b=" << b_yy << endl;//100//引用注意事项//引用必须初始化int a_zy = 10;//int &b_zy; //错误，必须要初始化int &b_zy = a_zy;//一旦初始化后，就不可以更改cout << "a=" << a_zy << endl;//输出10cout << "b=" << b_zy << endl;//输出10//引用在初始化后，不可以改变int c_zy = 20;b_zy = c_zy;//赋值操作，而不是更改引用//把b_zy赋值了20，此时a_zy和b_zy都是20cout << "a=" << a_zy << endl;//输出20cout << "b=" << b_zy << endl;//输出20cout << "c=" << c_zy << endl;//输出20/*引用做函数参数*///作用：函数传参时，可以利用引用的技术让形参修饰实参//优点：可以简化指针修改实参int a_yyhs = 10;int b_yyhs = 20;cout << "交换前：" << endl;cout << "a_yyhs=" << a_yyhs << "\tb_yyhs=" << b_yyhs << endl;mySwap01(a_yyhs, b_yyhs);//值传递，形参不会修饰实参，main函数仍然输出原来的值cout << "值传递交换后：" << endl;cout << "a_yyhs=" << a_yyhs << "\tb_yyhs=" << b_yyhs << endl;mySwap02(&a_yyhs, &b_yyhs);//地址传递，形参会修饰实参cout << "地址传递交换后：" << endl;cout << "a_yyhs=" << a_yyhs << "\tb_yyhs=" << b_yyhs << endl;mySwap03(a_yyhs, b_yyhs);//引用传递，形参会修饰实参cout << "引用传递交换后：" << endl;cout << "a_yyhs=" << a_yyhs << "\tb_yyhs=" << b_yyhs << endl;//通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单/*引用做函数返回值*///作用：引用是可以作为函数的返回值存在的//1.不要返回局部变量的引用int &ref = test03();cout << "ref=" << ref << endl;//第一次正确，输出10，是因为编译器做了保留cout << "ref=" << ref << endl;//第二次错误，因为内存已经释放int & ref2 = test04();cout << "ref2=" << ref2 << endl;//输出10cout << "ref2=" << ref2 << endl;//输出10//2.函数的调用可以作为左值test04() = 1000;//函数调用作为左值，必须返回引用，这就相当于a=1000的赋值操作cout << "函数调用作为左值赋值后：" << endl;cout << "ref2=" << ref2 << endl;//输出1000cout << "ref2=" << ref2 << endl;//输出1000/*引用的本质*///本质：引用的本质在C++内部实现是一个指针常量,一旦初始化后就不可以发生改变int a_bz = 10;          //自动转换为 int* const ref = &a; 指针常量是指针指向不可改，也说明为什么引用不可更改  int& ref_bz = a_bz;  ref_bz = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;       cout << "a:" << a_bz << endl;  cout << "ref:" << ref_bz << endl;      func5(a_bz);  /*常量引用*///作用：常量引用主要用来修饰形参，防止误操作//在函数形参列表中，可以加const修饰形参，防止形参改变实参//语法：返回值类型 函数名称（const 变量类型 & 引用名称）{ 函数体语句；return语句；}int a_xs = 10;//int &ref_xs = 10;//错误，引用必须引一块合法的内存空间const int & ref_xs = 10;//正确，加上const以后，编译器将代码修改为int temp=10;const int & ref_xs=temp;//ref_xs = 20;//错误，加入const之后变为只读，不可以修改//打印a_xsshowValue(a_xs);//输出1000cout << "a_xs=" << a_xs << endl;//输出1000//防止误操作int b_xs = 20;showValue2(b_xs);//输出20cout << "b_xs=" << b_xs << endl;//输出20/*函数默认参数*///在C++中，函数的形参列表中的形参是可以有默认值的//语法：返回值类型 函数名称（参数=默认值）{ 函数体语句；return语句；}//如果我们自己传入数据，就用自己的数据；如果没有，那么用默认值cout << func6(10) << endl;//10+20+30=60cout << func6(10,30) << endl;//10+30+30=70//注意事项//1.如果某个位置已经有了默认参数，那么从这个位置往后都必须有默认值//2.如果函数声明有默认参数，函数实现就不能有默认参数cout << func8(10, 20) << endl;/*占位参数*///C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置//语法：返回值类型 函数名（参数1，...,数据类型）{ 函数体语句；return语句；}func9(10,1);//占位参数必须填补//func9(10) //占位参数有默认值/*函数重载*///函数重载满足条件：//1.同一个作用域下//2.函数名称相同//3.函数参数类型不同或者个数不同或者顺序不同//注意：函数的返回值不可以作为函数重载的条件funct();funct(10);funct(3.14);funct(10, 3.14);funct(3.14, 10);/*函数重载注意事项*///1.引用作为重载条件//int a_cz = 10;//fun(a_cz); //调用fun（int &a)fun(10);//调用fun(const int &a)//2.函数重载碰到默认参数//fun2(10);//当函数重载碰到默认参数，出现二义性，报错，尽量避免这种情况system("pause");return 0;
}

C++学习笔记（十）成员变量和成员函数分开存储、this指针、空指针访问成员函数、const修饰成员函数、友元相关推荐

1. C++ 学习笔记之(19) new、delete表达式、RTTI(运行时类型识别)、枚举、类成员指针、嵌套类、局部类、位域、volatile、extern C

   C++ 学习笔记之(19) new.delete表达式.RTTI(运行时类型识别).枚举.类成员指针.嵌套类.局部类.位域.volatile.extern C C++ 学习笔记之(19) new.de ...

2. IOS之学习笔记十五(协议和委托的使用)

   1.协议和委托的使用 1).协议可以看下我的这篇博客 IOS之学习笔记十四(协议的定义和实现) https://blog.csdn.net/u011068702/article/details/809 ...

3. Python语言入门这一篇就够了-学习笔记(十二万字)

   Python语言入门这一篇就够了-学习笔记(十二万字) 友情提示:先关注收藏,再查看,12万字保姆级 Python语言从入门到精通教程. 文章目录 Python语言入门这一篇就够了-学习笔记(十二万字 ...

4. windows内核开发学习笔记十五：IRP结构

   windows内核开发学习笔记十五:IRP结构   IRP(I/O Request Package)在windows内核中,有一种系统组件--IRP,即输入输出请求包.当上层应用程序需要访问底层输入输 ...

5. 吴恩达《机器学习》学习笔记十——神经网络相关（2）

   吴恩达<机器学习>学习笔记十--神经网络相关(2) 一. 代价函数 二. 反向传播算法 三. 理解反向传播算法 四. 梯度检测 五. 随机初始化 1.全部初始化为0的问题 2.随机初始化的 ...

6. mysql 临时表 事务_MySQL学习笔记十：游标/动态SQL/临时表/事务

   逆天十三少 发表于:2020-11-12 08:12 阅读: 90次 这篇教程主要讲解了MySQL学习笔记十:游标/动态SQL/临时表/事务,并附有相关的代码样列,我觉得非常有帮助,现在分享出来大家一 ...

7. ROS学习笔记十：用C++编写一个简单的服务和客户端

   ROS学习笔记十:用C++编写一个简单的服务和客户端 这一节主要介绍如何使用C++编写一个简单的服务和客户端节点. 编写服务节点 由于在前面的练习中,已经向beginner_tutorials软件包中 ...

8. python3.4学习笔记(十八) pycharm 安装使用、注册码、显示行号和字体大小等常用设置...

   python3.4学习笔记(十八) pycharm 安装使用.注册码.显示行号和字体大小等常用设置 Download JetBrains Python IDE :: PyCharm http://ww ...

9. 哈工大操作系统学习笔记十——信号量与死锁

   哈工大os学习笔记十(信号量与死锁) 文章目录 哈工大os学习笔记十(信号量与死锁) 一. 信号量临界区保护 1.为什么要保护信号量 2.临界区 3.保护信号量的方法 3.1 轮换法 3.2 标记法 ...

最新文章

1. C#图片压缩的实现方法
2. 高并发设计方案二（秒杀架构）
3. abap 导入队列末尾_在C#中将对象添加到队列的末尾-排队操作
4. 比特币Merkle树和SPV机制
5. MATLAB（四）在高等数学中的应用
6. jquery ajax 跨域请求
7. 12岁上大学，23岁获博士学位，这位天才科学家正式加盟清华
8. gitlab root
9. Bex5开发技巧之如何在列表中显示主键字段
10. 从Linux程序中执行shell（程序、脚本）并获得输出结果（转）
11. 面试题汇总2（吐血整理）
12. CVPPA彩色图片转COCO格式
13. cursor（鼠标手型）属性
14. 阿里巴巴原来这么容易就能进去…
15. 《关于2010年计算机信息系统集成项目经理资质申报有关事项的通知》
16. IDEA 快捷键 代码上移一行 下移一行 快捷键 try catch 块 快捷键
17. win7关机一直卡在正在关机
18. 国家计算机一级考试题库百度云,全国计算机一级考试题库
19. splatter包生成单细胞RNA测序数据
20. Mongodb 查询重复数据

热门文章

1. JAVA版B2B2C商城源码 多商家入驻商城系统 直播带货 新零售商城 o2o商城 电子商务 拼团商城
2. php创建不重复的7位数字,php如何生成不重复数字
3. Eclipse项目上的红叉解决方案
4. 首次创业者必须知道哪些基本常识？
5. java 导出excel表格并下载（poi）
6. vi命令-跳舞吧，手指
7. 快递员扫描的设备是什么
8. 坑！计蒜客——乳草的侵占
9. tensorflowJS入门以及数据可视化 美国金县的房价预测
10. Word怎么批量删除空行和空格？有技巧很简单！