C++类和对象及其函数

类（class)
是用户自定义数据类型。
如果程序中要使用类型，必须根据实际需要定义，或者使用好自己设计好的类

C++定义一个类，其方法与定义一个结构体类型是相似的，一般形式为：

类由三部分组成：类名，数据成员和成员函数。

class 类名
{
     private:
     public:
     protected:
};

类成员三种访问权限分别是 private(私有成员),public(公有成员),protected(受保护成员），
在每一种访问权限下，均可以定义数据成员和成员函数。
①私有成员private：
私有成员是在类中被隐藏的部分，它往往是用来描述该类对象属性的一些数据成员，私有成员只能用本类的成员函数或某些特殊说明的函数(如第四章要讲到的友元函数）访问，而类的外部函数根本无法访问私有成员，实现了访问权限的有效控制，使数据得到有效保护，有利于数据隐藏，使内部数据不能被任意地访问和修改，也不会对该类以外的其余部分造成影响，使模块之间耦合程度降到最低。private成员若处于类声明的第一部分，可省略关键字private。

②公有成员public：
公有成员对外是开放的，公有成员一般是成员函数，它提供了外部程序与类的接口功能，用户通过公有成员访问该类中的数据。

③受保护的成员protected：
只能由该类的成员函数、友元、公有派生类成员函数访问的成员。受保护的成员与私有成员在一般情况下含义相同，它们的区别体现在类的继承中对产生的新类的影响不同
缺省访问控制(未指定private、public、protected访问权限）时，系统认为是私有private 成员。
类具有封装性，C++语言中数据的封装通过类来实现的，外部不能随意访问权限说明为protected和 private的成员。
一般情况下，类名的第一个字母大写，以区别普通的变量与对象。
由于类的公有成员提供了一个类的接口，所以一般情况下，先定义公有成员，再定义保护成员和私有成员，这样可以在阅读时了解这个类的接口。当然。类声明中的三种访问控制权限说明，可以按任意次序出现任意次。
数据成员可以是任何数据类型，但不能用自动(auto)、寄存器(register)或外部(extern)进行说明。

总的来说

公有成员public对外是开放的，可以通过公有成员访问private成员和protected成员。

C++中的类中不能初始化的

class sb//错误的
{
   public:
   int a=10;	
};

例子

#include <bits/stdc++.h>
using namespace std;

class Student 
{
	private:
		int id;
		string name;
		double score;
	public:
		void sin(int d, string ame, double core) 
		{
			id = d;
			name = ame;
			score = core;
		}
		void print() 
		{
			cout << "学号：" << id << endl;
			cout << "姓名：" << name << endl;
			cout << "分数：" << score << endl;
		}
};

int main () {
	Student s;
	s.sin(2021, "FH", 90);
	s.print();
	return 0;
}

也可以用指针初始化
定义了类及其对象，就可以定义成员函数实现对对象内部属性的访问。当然不论是数据成员还是成员函数，只要是有公有(public)，在类的外部就可以通过类的对象进行访问，对公有成员的调用可以通过以下几种方法来实现。
通过对象调用成员。
格式：
对象名、公有成员
其中点称之为对象选择符，简称为点运算符。
通过指向对象的指针来调用成员。
指向对象的指针>成员
(*对象指针名).公有成员格式：
对象的引用.成员
需要注意，只有用public定义的公有成员才能使用原点运算符访问。对象中私有成员是类中隐藏的数据，类的外部不能访问对象的私有成员，只能通过该类的公有成员函数来

#include <iostream>
using namespace std;

class Student 
{
	private:
		int id;
		string name;
		double score;
	public:
		void sin(int d, string ame, double core) 
		{
			id = d;
			name = ame;
			score = core;
		}
		void print() 
		{
			cout << "学号：" << id << endl;
			cout << "姓名：" << name << endl;
			cout << "分数：" << score << endl;
		}
};

int main () 
{
	Student s, *p;
	p = &s;
	p->sin(2021, "FH", 90);
	p->print();
	return 0;
}

类的数据成员说明对象的特征，
如Student 类中的数据成员表示学号的id，姓名name和分数 score。
成员函数决定对象的操作行为。成员函数是程序算法实现的部分，是对封装数据进行操作的唯一途径。
如Student 类中的初始化的成员函数void set(int sid，string sname，doublesscore)；
打印成员函数void print()；
就是如此。
类成员函数有两种定义方法：外联定义与内联定义。
1.外联成员函数（外联函数）
外联定义成员函数是指在类定义体中定义成员函数。在类中定义成员函数时，它所带
的函数参数可以指出其类型，而省略参数名；在类外定义成员函数时，必须在函数名前缀
上类名，在函数名和类名之间加上作用域区分符：：，作用域区分符指明数据成员和成员数
据所在的类。作用域区分符：：若不加类名，则成为全局数据或全局函数（非成员函数）。
在类外定义成员函数的具体形式如下。
返回值类型类名：：成员函数名(形式参数表)

#include <iostream>
using namespace std;

class Student {
	private:
		int id;
		string name;
		double score;
	public:
		void sin(int d, string ame, double core);
		void print();
};

void Student::sin(int d, string ame, double core) {
	id = d;
	name = ame;
	score = core;
}

void Student::print() {
	cout << "学号：" << id << endl;
	cout << "姓名：" << name << endl;
	cout << "分数：" << score << endl;
}

int main () {
	Student s, *p;
	p = &s;
	p->sin(2021, "FH", 90);
	p->print();
	return 0;
}

使用关键字inline定义内联成员函数（显示声明）。
如果定义在类定义体外的函数使用关键字inline，则可以将定义在类定义体外的融声明为内联函数，这时可以在类定义体内相应函数的前面增加关键字inline，将该函数明为内联函数。

#include <bits/stdc++.h>
using namespace std;

class Student 
{
	private:
		int id;
		string name;
		double score;
	public:
		void inline sin(int d, string ame, double core) 
		{
			id = d;
			name = ame;
			score = core;
		}
		inline void print() 
		{
			cout << "学号：" << id << endl;
			cout << "姓名：" << name << endl;
			cout << "分数：" << score << endl;
		}
};

int main () 
{
	Student s;
	s.sin(2021, "FH", 90);
	s.print();
	return 0;
}

函数跟函数一样，可以重载函数：

#include <bits/stdc++.h>
using namespace std;

class Student 
{
	private:
		int id;
		string name;
		double score;
	public:
		void inline sin(int d, string ame, double core) 
		{
			id = d;
			name = ame;
			score = core;
		}
		inline void print() 
		{
			cout << "学号：" << id << endl;
			cout << "姓名：" << name << endl;
			cout << "分数：" << score << endl;
		}
};

int main () 
{
	Student s, s1;
	s.sin(2021, "FH", 90);
	s.print();
	s1.sin(2021, "FG", 98);
	s1.print();
	return 0;
}

析构函数：
当对象脱离其作用域时（例如对象所在的函数已调用完毕），系统会自动执行析构函数。析构函数往往用来做“清理善后”的工作（例如在建立对象时用new开辟了一段内存空间，则在该对象消亡前应在析构函数中用delete释放这段存储空间）。 C++规定析构函数的名字是类名的前面加一个波浪号（~）。其定义形式为：
~类名（）
{
函数体
}
析构函数不返回任何值，没有返回类型，也没有函数参数。
由于没有函数参数，因此它不能被重载。换言之，一个类可以有多个构造函数，但是只能有一个析构函数

1.析构函数由系统自动调用释放一个对象时，系统将自动地为该对象调用析构函数
2.目的：进行一些与该对象有关的销毁性工作
3.用new分配的动态对象在释放时，系统要为该动态对象调用析构函数

#include<iostream>
using namespace std;
class Myclass
{
	public:
		Myclass()
		{
			cout<<"Myclass conts"<<endl;
		}
		~Myclass()
		{
			cout<<"Myclass Dels"<<endl;
		}
};
Myclass myGlobal;
int main()
{
	Myclass my1,my2;
	Myclass *Pmy=new Myclass();
	delete Pmy;
 }

缺省函数
3.缺省构造函数（默认构造函数）
(1）缺省构造函数。
背景：C++规定，每个类必须有一个构造函数，没有构造函数，就不能创建任何
若用户未显式定义一个类的构造函数，则C++提供一个缺省的构造函数，也叫默认函数。
功能：缺省构造函数是个无参构造函数，它仅负责创建对象，而不做任何初工作。
注意：只要一个类定义了一个构造函数（不一定是无参构造函数），C++就不再提认的构造函数。
如果为类定义了一个带参数的构造函数，还想要使用无参构造函数，须自己定义。与变量定义类似，
在用默认构造函数创建对象时，如果创建的是全局对静态对象，则对象的位模式全为0，否则，对象值是随机的。

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

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

对象数组

#include <bits/stdc++.h>
using namespace std;

class Student 
{
	private:
		int id;
		string name;
		double score;
	public:
		void inline sin(int d, string ame, double core) 
		{
			id = d;
			name = ame;
			score = core;
		}
		inline void print() 
		{
			cout << "学号：" << id << endl;
			cout << "姓名：" << name << endl;
			cout << "分数：" << score << endl;
		}
};

int main () 
{
	Student s[100];
	s[0].sin(2021, "FH", 90);
	s[0].print();
	return 0;
}