Ninth 类、默认参数、函数重载

原文链接（点击原文链接获取更多学习干货）：

http://blog.bools.cn/archives/1369

1.类

1.类的权限

类是由class来命名，可以装下一些属性（可以理解为变量）和一些行为（可以理解为一些函数），那么类和结构体是很相似的，而他们的一个大不同就在访问权限那里。

类当中，本来的权限是private，就是私人的意思，意思是定义的属性和i行为只能在类当中使用。

class circle
{
	int m_r;
	double countZC()
	{
		return 2 * pi * m_r;
	}
};
void printf_ZC()
{
	circle c1;
	c1.m_r = 6;//出错，因为权限只能在类里面使用
}

权限还有public，就是公开的意思，当然在一个类当中，可以定义一些是public的，一些是private的。而还有一种权限是protected，就是保护的意思，类内部和类子集可以访问，而外部不可访问。

而一个类的基本流程是

 在类的权限设置之后，我们可以将属性直接用到了类当中的函数当中，不需要调用。而设置成public的话，我们也可以用函数来设置属性。

class circle
{
public:
	int m_r;
	double countZC()
	{
		return 2 * pi * m_r;
	}
};
void printf_ZC()
{
	circle c1;
	c1.m_r = 6;
	double girth_r = c1.countZC();
	cout << "周长为：" << girth_r << endl;
}

 

 

2.内联函数

在C++中，预定义宏的概念是用内联函数来实现的，而内联函数本身也是一个函数。内联函数具有普通函数的属性和所有行为，而和普通函数不同的就是内联函数会在适当的地方会像预定义宏一样展开，所以不需要函数调用的开销，因此应该不使用宏，而用内联函数。

在普通函数的前面加上inline关键词使之成为内联函数，但是注意必须函数体和声明结合在一起，否则还是普通函数

inline void test(int x);
inline void test(int x)
{
	cout << x << endl;
}

内联函数的确占空间，但是内联函数相对于普通函数的优势只是省去了函数调用时的压栈，跳转，返回的开销。我们可以理解为内联函数时用空间换时间。

而在类内部定义的函数会自动成为内联函数，（怪不得运行那么慢）

因为内联函数时用空间来换时间的，编译器会有一些限制，所以对此由几个建议，以下情况编译器可能不会讲函数当内联函数来处理。

1.不能存在任何形式的循环语句

2.不能存在过多的条件判断语句

3.函数体不能过于庞大

4.不能对函数进行取址操作

总言之：内联函数就是解决宏缺陷的问题。

2.默认参数

默认参数就是在直接给调用函数的参数一个值

void func(int a = 10, int b = 20)
{
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
}

那么在调用函数时，当然也可以赋值，不过会将默认的值覆盖。

这里注意，如果一个位置有了默认参数，那么这个位置的后面，从左到右必须右默认参数

void func2(int a, int b = 10, int c = 20)
{
	cout << "a+b+c=" << a + b + c << endl;
}

函数调用的时候，有时需要声明，而声明和定义两个之中，只能由一个由默认参数，比如

	void func3(int a = 10, int b = 30);
    void func3(int a, int b)
    {
    	cout << "a+b=" << a + b << endl;
    }

3.函数重载

在C++中，函数名可以重复，但必须在同一个作用域内，函数名称相同

而重载的条件是，函数的参数个数不同，或者类型不同或者顺序不同，返回值不同不能作为函数重载的条件。

void func4(int a)
{
	cout << "有int参数的重载函数" << endl;
}
void func4(int a, int b)
{
	cout << "有两个int类型的参数的重载函数" << endl;
}
void func4(float a, float b)
{
	cout << "有两个float类型的重载函数" << endl;
}
void func4(int b, int a)
{
	cout << "不同顺序的重载函数" << endl;
}

但在调用函数时，要注意二义性

	
void func4(int a, int b)
{
	cout << "有两个int类型的参数的重载函数" << endl;
}
void func4(int b, int a)
{
	cout << "不同顺序的重载函数" << endl;
}
    func4();
	func4(a);
	func4(a,b);//产生了二义性
	func4((float)a, (float)b);

函数的重载，也可以用引用来作为条件

void func4(const int& a)
{
	cout << "const可以作为函数重载的条件" << endl;
}