(2)C++类和面向对象

---

类和面向对象(1)

---

理论

类和对象的关系：
1.面向对象是一种编程思想
2.类是一种语法
3.语法是实现编程思想的基础

类

定义：(1)具有相同属性（数据成员）和行为（函数）的对象的集合，比如：
人类是一个人的集合，而我就是这个类的具体个体，称作对象
(2)类是一种语法，关键字是class，而C语言的struct则是类的特殊情况
(3)注意：
类成员赋值：可以在类内，不过对于有些编译器只有静态常量整形才能在类中初始化；最好利用对象在主函数赋值（移植性高）
但在调用时，数据成员太多，一个一个调用太麻烦，这是我们可以利用函数函数成员来装其他数据成员，最后直接调用函数即可，代码如下：

#include<iostream>
using namespace std;

class Cstu
{
public:
	int age ;//整形数据成员;
	char strong;
	float Heigh ;
	void message() //特别申请一个函数给其他成员初始化  用的时候直接用就好了
	{
		age = 20;
		strong = 'a';
		Heigh = 1.73f;
	}
};
int main()
{
	Cstu we;  //声明一个Cstu类的对象
	we.message();  //调用初始化函数
	cout << we.age << endl;
	system("pause");
	return 0;
}

但有时候会忘了调用：we.message();所以C++采取了构造函数（见下章）
成员调用：
1.栈区普通对象调用
2.堆区指针对象调用
3.类的所有成员（除个别特殊static），必须通过对象访问
4.类和对象的使用：

#include<iostream>
using namespace std;

class Cpeople
{
public:    //访问修饰符
	int a;
	void fun()
	{
		cout << "fun:" << a << endl;
	}
};
int main()
{
	/*两种声明对象的方式：栈区普通变量和堆区指针变量*/
	Cpeople we;//声明对象  we（栈区的）就是Cpeople这个类的一个对象
	//指针变量类空间并未申请出来，要申请一个堆区的空间Cpeole 空间才算出来
	Cpeople *we1 = new Cpeople;//声明一个指针对象   
	
	//调用栈区普通成员
	we.a = 12;
	we.fun();
	//调用堆区指针成员
	we1->a = 14;
	we1->fun();
	system("pause");
	return 0;
} 
//we这样的对象可以声明无数个  类是所有对象的公共属性的集合

访问修饰符：
作用范围：从书写位置到下个访问修饰符结束，或者到类结尾花括号结束
作用：可作为类内成员分类的工具（对类内某些特定共同功能的代码块进行分类）

一个类内可写多个访问修饰符：

class Cpeople
{
	int a;
public:
	void we()
	{
		cout << "we" << endl;
	}
private:
	void fun3()
	{
		we();
	}
};

1.public
(1)使类内成员对外可见
(2)对其他类可见
(3)对其他函数可见
(4)不写会报错：无法访问私有成员

class Cpeople
{
public:
	int a;
	void we()
	{
		cout << "we" << endl;
	}
};
//对其他类可见
class Cperson
{
public:
	Cpeople westrong1;
	void we2()
	{
		//对其他函数可见
		Cpeople westrong2;
		cout << "we1" << endl;
	}
};

2.private(与public对比)
(1)无访问修饰符时，默认是private修饰符
特别的：struct 默认是public

struct we  //加上就变成私有的了
{
private:
	int a = 12;
};

(2)仅类内可见

3.protected
功能：仅类内以及类的子类可见

class westrong//声明类
{
protected:
	int a = 12;
	void we()
	{
		cout << a << endl;
	}
};
//westrong子类
class wq : public westrong
{
	void fun()
	{
		we();
	}
};

4.友元
关键字：friend

功能：使私有成员对指定项可见
比如：一个private的成员，一个函数在类内声明了它的友元函数之后，这个友元函数就可以直接使用私有成员了

特点：不受访问修饰符影响；可有多个友元；

private: //无用
	friend void fun1(); 

破坏了类的封装性，最好不要用。那私有的该如何访问呢？
这就有了接口函数：

	//接口函数   友元建议不要用，就用接口函数
public: 
	int Get()//得值
	{
		return age;
	}
	void Set()//赋值
	{
		age = 13;
	}
	//调用接口函数
	Cstu we1;
	we1.Set();
	int a = we1.Get();  //有返回值可以用变量接着
	cout << a << endl;

(1)在一个类内声明了友元函数，那么这个函数可以使用类内的任何成员

class Cstu
{
private:
	int age = 12;
	void fun()
	{
		cout << age << endl;
	}
	friend void fun1();  //将fun1()声明成友元函数 fun1内可使用私有类
	friend int main();  //主函数也是一样
	friend class Cteach; //友元类也是一样
};

(2)成员利用友元的访问，继承(子类)

(3)通过友元使得公有类调用私有类成员总代码：

#include<iostream>
using namespace std;

class Cstu
{
private:
	int age = 12;
	void fun()
	{
		cout << age << endl;
	}
	friend void fun1();  //将fun()声明成友元函数
	friend int main();  //主函数也是一样
	friend class Cteach; //友元类也是一样
};
class Cteach
{
public:
	Cstu we;
	void fun2()
	{
		we.fun();
	}
};
void fun1()
{
	Cstu we;  //声明对象
	we.fun(); //调用fun();
}
int main()
{
	Cteach Teach;
	Teach.fun2();  
	system("pause");
	return 0;
}