c++学习之路

【3.19】内存分区模型
内存四区意义:
不同区域存放的数据，赋予不同的生命周期,给我们更大的灵活编程
程序exe 运行前分为 代码区和全局区；运行后分为 栈区和堆区

1.代码区:存放CPU执行的机器指令,存放函数体的二进制代码，由操作系统进行管理的
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令
2.全局区:存放全局变量和静态变量以及常量
全局变量和静态变量（static）存放在此.
全局区还包含了常量区,字符串常量和其他常量(const修饰的全局变量)也存放在此
该区域的数据在程序结束后由操作系统释放

【3.20】3.栈区：由编译器自动分配释放,存放函数的参数值,局部变量等
注意事项:不要返回局部变量的地址，栈区开辟的数据由编译器自动释放

存放函数内部变量和形参

4.堆区：由程序员分配释放摇程序员不释放,程序结束时由操作系统回收
在C++中主要利用new在堆区开辟内存–>返回的是一个该类型的指针
delete释放内存，释放数组时需要delete[]+数组名

引用：
(1)一旦初始化为一个变量的别名后就不可以更改

(2)引用做函数参数：
一般函数的形参传递有两种，①值传递，不可以修改实参。②通过指针地址传递，可以修改实参。

void swap01(int a ,int b){
	int temp = a;
	a = b;
	b = temp; 
}
void swap02(int *a ,int *b){
	int temp = a;
	a = b;
	b = temp; 
}
void swap03(int &a ,int &b){
	int temp = a;
	a = b;
	b = temp; 
}


int main(){
	int a =10;
	int b =20;
//值传递
	swap01(a,b);
	cout << a<< endl; //10 值传递，没发生改变
	cout << b<< endl; //20 形参不会修饰实参
//地址传递
	swap02(&a,&b);
	cout << a<< endl; //20
	cout << b<< endl; //10 形参会修饰实参
//引用传递
	swap03(a,b);//传入a,b 接收时用a,b一样的别名接收 
	cout << a<< endl; //20 //所以在函数中对别名做修改，就是在修改原变量
	cout << b<< endl; //10 形参会修饰实参
	
	return 0;
}

(3)不要返回局部变量的引用，系统已在函数结束时释放内存
(4)如果函数的返回值是引用，这个函数可以作为左值

int& test(){
	static int a =10;//不放在栈区，放在了全局区，函数结束时内存不会被释放
	return a;//以引用的形式返回a
}
int main(){
	int &ref = test();//调用函数返回a的引用，用引用ref接到引用a
	cout << ref << endl; //10
	test() = 1000;//将1000赋值给函数返回的a的引用
	cout << ref << endl; //1000 打印a的另外引用 ref
return 0;
}

(5)引用的本质
引用的本质是一个 指针常量，有关指针的操作编译器帮我们抵挡在底层了

//发现是引用，转换为int* const ref = &a;
void func(int& ref){
	ref = 100; // ref是引用，转换为*ref = 100
}
int main(){
inta.10;
//自动转换为int* const ref = &a;指针常量是指针指向不可改，也说明为什么引用不可更改
int& ref . a;
ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;
cout << "a:" << a << endl;
cout << "ref:" << ref << endl;
func(a);
return 0;
}

【3.20】
（1）函数的默认参数

int func(int a，int b = 10，int c = 10){
	return a + b +c;
}
//1．如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
//2．如果函数声明有默认值，函数实现的时候就不能有默认参数
int func2(int a = 10， int b = 10);//声明
int func2(int a， int b){//实现
return a + b;
}

（2）函数重载
作用:函数名可以相同，提高复用性
函数重载满足条件:
·同一个作用域下·函数名称相同
·函数参数类型不同或者个数不同或者顺序不同
注意:函数的返回值不可以作为图数重载的条件
注意事项：
引用作为重载的条件
①加不加const的引用可以作为区分

void func(int &a)

void func(const int &a)

a=10
func（a）//调用无const的，因为a是变量
func（10）//调用有const的，因为10是常量

②函数重载时如果函数有默认参数，会产生二义性

void func2(int a, int b = 10){
cout <<"func2 (int a, int b = 10)调用"<< endl;}
void func2(int a){
cout <<""func2(int a)调用”<<endl;}

func2(10)//调用时有歧义

【3.22】
类的访问权限
关键字 public 确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。
proctected为保护权限，成员类内可以访问﹐类外不可以访问—>儿子可以访问父亲中的保护内容
私有权限private，成员类内可以访问﹐类外不可以访问—>儿子不可以访问父亲的私有内容

class与struct的区别在于默认权限不一样
class为私有private
struct为共有public

【3.23】
（1）类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。可以有参数，可以参数重载。构造函数可用于为某些成员变量设置初始值。

分类：
按参数分①有参构造
②无参构造
按类型分①普通构造
②拷贝构造

（2）类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

（3）调用的方法
①括号法
②显示法
③隐式转换法

class Line{
   public:
      int getLength( void );
      Line();//无参函数构造
      Line( int len ){ // 简单的构造函数 有参构造
		len = len
	};             
      Line( const Line &obj){// 拷贝构造函数
		len = Line.len//将传入的line属性拷贝当前
};      
      ~Line();         // 析构函数
};

int main(){
//1.括号法
	Line l1;//默认构造函数调用  
	Line l2(10);//有参构造函数调用
	Line l3(l2);//拷贝构造函数调用 长度也是10
	//注意不要加小括号
	Line l1();//这句话会被认为是函数的声明，而不是创建对象语句
//2.显示法
	Line l1 = Line（10）；//有参构造函数调用 右边也称为匿名对象，当前行执行结束后系统立即回收掉
	Line l2 = Line (l1);//拷贝构造函数调用 长度也是10
	//注意不要使用拷贝构造函数 初始化匿名对象
	Line (l2)//系统认为这句等价于Line l2 与上一句一样，重定义了
//3.隐式转换法
	Line l4 = 10;//相当于写了Line l4 = Line(10)
	Line l5 = l4//;//拷贝构造函数调用 长度也是10

return 0;
}