C++学习记录（3）

1.设计一个类，求圆的周长
1.1 class + 类名{ 成员变量 成员函数 }
1.2 公共权限 public:
1.3 设计成员属性
1.3.1 半径 int m_R;
1.4 设计成员函数
1.4.1 获取圆的周长 int calculateZC（）
1.4.2 获取圆的半径 int getR（）
1.4.3 设置圆的半径 void setR()
1.5 通过类创建对象的过程 称为 实例化对象

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//设计一个类，求圆的周长
const double PI = 3.14;
//class + 类名
class Circle
{
public: //公共权限

	//类中的函数称为成员函数 成员方法 
	//求圆的周长
	double calculateZC()
	{
		return 2 * PI * m_R;
	}
	//半径  类中的变量称为是成员变量 成员属性
	int m_R;

	//设置半径
	void setR(int r)
	{
		m_R = r;
	}

	//获取半径
	int getR()
	{
		return m_R;
	}
};

void test1_1()
{
	Circle c1; //通过类来创建一个对象 实例化一个对象

	//给c1的半径赋值
	//c1.m_R = 10;
	c1.setR(10);

	//求c1圆的周长
	cout << "圆的周长是" << c1.calculateZC() << endl;
	cout << "圆的半径为" << c1.getR() << endl;
}
int main()
{
	test1_1();


	system("pause");
	return EXIT_SUCCESS;
}

2.函数重载（重点）

2.1 函数重载是：允许函数名相同，这种现象叫函数重载
2.2 函数重载作用：是为了方便使用函数名
2.3函数重载的条件：同一个作用域、参数的个数不同、参数的顺序不同、参数的类型不同

//参数的个数不同
void func()
{
	cout << "func" << endl;
}

void func(int a)
{
	cout << "func(int a)" << endl;
}

//参数的类型不同
void func(char c)
{
	cout << "func(char c)" << endl;
}

//参数的顺序不同
void func(int a, double b)
{
	cout << "func(int a, double b)" << endl;
}

void func(double b, int a)
{
	cout << "func(double b, int a)" << endl;
}

2.4 调用重载函数的注意
2.4.1 严格的类型匹配，如果类型不匹配那么尝试转换，转换成功就调用，失败就报错。

void test3_1()
{
	int a = 10;
	double b = 3.14;
	func();
	//func(b);//double转换不成char或者int
	func(a, b);
	func(b, a);

	char c = 'c';
	func(c); //char可以转换为int类型，如果没有匹配到char类型的参数可以调用int参数的函数
}

2.5 函数重载和函数默认参数一起使用，需要注意二义性问题

//函数重载和函数默认参数一起使用
void myfunc(int a, int b = 0)
{
	cout << "myfunc(int a, int b = 0)" << endl;
}

void myfunc(int a)
{
	cout << "myfunc(int a)" << endl;
}

void test3_2()
{
	//myfunc(10); 会出现二义性的问题，不知道调用哪个函数
}

2.6 函数的返回不作为函数重载的条件

3.函数重载的原理（重点）

3.1 函数重载的原理是在汇编时，给各个函数取别名，C语言不可以重载的原因是没有取别名

4.C++调用C语言的函数（重点）

4.1 C++的函数在汇编时会给函数取别名，C语言不会，这时如果C++来调用C语言的函数，那么C++会去找取了别名的函数，但是C语言没有取别名，这时会出错

test.h文件中

//这是告诉C++编译器，找下面的函数，要以C语言的方式去寻找
#ifdef __cplusplus
extern "C"
{
#endif
	void func(); //C语言的函数声明


#ifdef __cplusplus
}
#endif

5.类和对象的概念（重点）

5.1 类是自定义数据类型，是C语言的结构体进化而成的
5.2 对象是类实例化出的，通俗讲，是用一个数据类型来定义变量

class Maker //这个是类
{
public:
	int a; //成员属性 （成员变量）
	void func() //成员方法 （成员函数）
	{
		cout << "func" << endl;
	}
};
int main()
{
	Maker m; //m就是对象


	system("pause");
	return EXIT_SUCCESS;
}

6.类的封装（重点）

6.1 封装：把属性（变量）和方法（函数）封装到类内，然后给这些数据赋予权限
6.2 为什么要有封装
（1）防止乱调用函数和变量，出现错误
（2）维护代码更方便
6.3 权限

//封装：1. 把属性和方法放到类中。2.给这些数据赋予权限
class Maker
{
public: // 公有权限
	void set(string Name, int Id)
	{
		id = Id;
		name = Name;
	}
	void printMaker()
	{
		cout << "id=" << id << " name=" << name << endl;
	}

private: // 私有权限
	int id;
	string name;

protected: //保护权限
	int a;
};

class Son :public Maker
{
	void func()
	{
		a = 20; //子类的类内可以访问父类的保护权限的成员
	}
};
//类外可以访问共有权限的成员
//类外不可以访问私有权限的成员
//类外不可以访问受保护权限的成员
//子类的类内可以访问父类的保护权限的成员
//类内没有权限之分

void test3_1()
{
	Maker m;
	m.set("小花", 1);
	m.printMaker();
}

6.4 尽量把属性设置为私有权限
6.4.1 可以控制属性的读写权限
6.4.2 可以赋予客户端访问数据的一致性

class Maker
{
public:
	//写
	void setName(string Name)
	{
		name = Name;
	}
	//读
	string getName()
	{
		return name;
	}
	//写
	void setAge(int Age)
	{
		//可以保护属性的合法性
		if (Age > 0 && Age < 120)
		{
			age = Age;
		}
	}
	//读
	int getId()
	{
		return id;
	}
private:
	string name;
	int age;
	int id;
};
int main()
{
	Maker m;
	m.getId();


	system("pause");
	return EXIT_SUCCESS;
}