c++学习笔记（6）

引用的本质
本质：引用的本质在c++内部的实现是一个指针常量
即指向的内存不可以更改，但是储存的值可以更改

int &ref = a；
//自动转换为int * const ref = &a
ref = 20；
//内部发现ref是引用，自动转换为*ref = 20
//本质也是指针

常量引用
作用：常量引用主要用来修饰常量，防止误操作
在函数的形参列表中，可以加const修饰形参，防止形参改变实参

int a = 10;
const int & ref = 10;
//加入const之后编译器将代码修改为 int temp = 10；
//const int & ref = 10；
ref = 20；
//错误，加入const之后只读，不可以修改

void showvalue（const int &val）
{
	cout<<val<<end1;
}
showvalue(a);

函数默认参数
在c++，函数的形参列表中的形参是可以有默认值的
语法：返回值类型 函数名 （参数 = 默认值）{}

int func(int a,int b = 20,int c = 30)
{
	return a+b+c;
}
func(10);
//b和c存在默认值，所以可以只输出一个参数

func(10,30);
//如果传入了b的值，会覆盖默认值，用自己传入的数据

注意事项
1.如果某个位置已经有了默认参数，那么从这个位置往后，都必须有默认值
2.如果函数声明有默认参数，函数实现就不能有默认参数

int func(int a = 20,int b = 10);

int func(int a = 20,int b = 10)
{
	return a+b;
}
//错误，声明跟实现只能有一个有默认参数，否则会变成重复定义

函数占位参数
c++中函数的形象列表里可以有占位参数，用来做占位，调用函数时必须填补该位置
语法：返回值类型 函数名 （数据类型）{}

void func(int a,int = 10)
{
	cout<<a<<end1;
}

func(10,10);
//传入数据时也要包括占位参数
//传入的参数在函数体中无法调用
//占位参数可以加默认值

函数重载
作用：函数名可以相同，提高复用性

函数重载满足条件
1.同一个作用域下
2.函数名称相同
3.函数参数类型不同，或者个数不同或者顺序不同

void func()
{
}

void func(int a)
{	
	cout<<a<<end1;
}

func();
func(10);
//根据传入的参数不同，调用不同的函数

函数的返回值不可以作为重载的条件

函数重载的注意事项
1.引用作为重载的条件
2.函数重载碰到默认参数

void fun(int &a)
{
	cout<<a<<end1;
}

void fun(const int &a)
{
	cout<<a<<end1;
}

int a = 10;
fun(a);
//a定义是一个局部变量，所以会调用第一个函数
fun（10）；
//会自动调用第二个，因为只有常量引用可以直接等于一个常量

void func(int a,int b = 10z)
{
	cout<<a<<end1;
}

void func(int a)
{
	 cout<<a<<end1;
}

func(10);
//会出现二义性，都可以接收一个参数

类和对象
c++面向对象的三大特性为：封装、继承、多态
c++认为万事万物都皆为对象，对象上有其属性和行为

封装
封装是c++面向对象三大特性之一
封装的意义：
将属性和行为作为一个整体，表现生活中的事物
将属性和行为加以权限控制

语法：class 类名（访问权限：属性/行为）；

const double pi = 3.14;

class circle
{
	//访问权限
public：//公共权限
	//属性
	int r;
	//行为
	double calculate()
	{
		return 2*pi*r;
	}
};

//创建对象
circle c1;
c1.r = 10;
//调用属性，给属性赋值
l = c.calculate();
//调用类里的函数

class student
{
	public//公公权限
	//属性
	string name;
	int id;
	
	void show()
	{
		cout<<name<<id<<end1;
	}

	void getname(string sname)
	{
		name = sname;
	}
};
student stu;//实例化
stu.name = "li";
stu.id = 10;
stu.show();

stu.getname("li");
stu.show();

类中的属性和行为 我们统称为 成员
属性 成员属性 成员变量
行为 成员函数

类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：
1.public 公共权限 成员类内可以访问 类外不可以访问
2.protected 保护权限 成员类内可以访问 类外不可以访问 子类可以访问父类中的权限
3.private 私有权限 成员类内可以访问 类外不可以访问

class person
{
public:
	string name;
protected:
	string car;
private:
	string password;
public:
	void func()
	{
		name = "li";
		car = "a";
		password = "123456"
		//类内可以正常访问
	}
person pl；
pl.name = "zh";
pl.car = "a";
pl.password = "123456";
//后两个错误，都不可以类外访问	
}

struct和class的区别
区别在于默认的访问权限不同
struct默认为public
class默认为private

class c1
{
	int a;
	//默认权限为私有
};

struct c2
{
	int a；
	//默认为公有权限
}s1;
c1.a = 100;
//错误
c2.a = 100;
//正确

成员属性设置为私有
1.将所有成员的属性设置为私有，可以自己控制读写权限
2.对于写权限，我们可以检测数据的有效性

class person
{
private:
	string name;//可读可写
	int age;//只读
	string parterner;//只写
public：
	void setname(string m_name)
	{
		name = m_name;
	}
	string show()
	{
		return name;
	}
}