C++中如何创建一个类？

1.创建类的语法

class 类名{

};
class是定义类的关键字，和struct基本相同

2.类里面的变量

类里的变量即属性 成员变量
把对象共同的特征抽象为属性(成员变量) 共性
成员变量 用来 描述 一类事物的特征

3.类里的函数

类里面的函数 即方法 成员方法(函数)
把对象共同的行为抽象为方法(函数)
成员方法 用来 描述 一类事物的行为

4.创建对象

类实例化具体的对象 属性赋值 给成员变量具体的值
类名 变量名;

C++中class的私有成员不能再用 = {}的形式来初始化

5.封装 访问控制属性

public 公开的 类里面 和 类外面可以直接访问
private 私有的 只允许在类里面访问
protected 保护的 只允许在本类 和 子类中访问

class与struct的区别

class类里面默认的访问控制属性 都是 私有的
struct里面默认的访问控制属性 都是 公开的

程序示例：

#include <iostream>
using namespace std;

class Stu{
	//访问控制属性  默认是private
//public:
	int no;
	string name;
	int age;
	int score;
public:
	Stu(){
		cout << "Stu()构造函数"<<endl;	
	}
	Stu(int n,string a,int g,int s){
		no = n;
		name = a;
		age = g;
		score = s;
		cout << "Stu(int,string,int,int) 构造函数"<<endl;
	}
	//函数  给属性赋值
	void init(int no1,string name1,int age1,int score1){
		no = no1;
		name = name1;
		age = age1;
		score = score1;
	}
	void show(){
		cout << no << ":" << name << ":" << age << ":" << score << endl;	
	}
};

class GirlFriend{
public:
	GirlFriend(){
		cout << "GirlFriend()构造函数"<< endl;	
	}
};
int main(){
	GirlFriend g;//实例化对象
	GirlFriend gs[10];


	Stu s;//实例化对象 调用构造函数  调用无参的构造函数  Stu()
	s.show();
	s.init(110,"张三",13,100);
	s.show();
	cout << "---------" << endl;
	Stu s1(110,"张四",14,100);
	s1.show();

	//Stu s1 = {};
	//Stu s1 = {110,"张三",13,100};//class中私有的成员不能再用{}的形式来初始化
	/*
	s.no = 10;
	s.name = "张三";
	s.age = 13;
	s.score = 100;
	*/
	return 0;	
}

6.初始化成员 — 构造函数

公开的属性 可以用 = {} 的形式 ，私有的和保护的不可以；
语法形式：
class 类名{
//构造函数
类名(形参列表){
//构造函数体
}
};

构造函数的特点：

1.构造函数没有返回值类型，也不可以是void；
2.构造函数的函数名和类型一致(一样)；
3.每一次在实例化对象时，都会自动调用构造函数 ；
4.一般在构造函数里会进行初始化属性(成员变量)；
5.一个类如果没有实现构造函数，编译器会自动生成一个无参的空构造函数；
默认生成的构造函数不会对基本数据类型进行初始化工作(垃圾值)；
对于类类型成员会调用其类型的无参构造函数；
但是当程序员自己提供构造函数以后，编译器将不会再自动生成构造函数；

6.构造函数可以重载

通过构造函数重载，可以按照不同的方式来构造对象

#include <iostream>
using namespace std;

//封装类   
class Circle{
private:
	double r;
public:
	//构造函数 方法  按照不同的方式来创建对象
	//在成员方法中可以直接访问成员函数
	Circle(double ar){
		r = ar;	
	}
	Circle(){
		r = 0;		
	}
	void setR(double ar){
		r = ar;
	}
	double getR(){
		return r;	
	}
	double len(){
		return 3.14*r*2;	
	}
	double area(){
		return 3.14*r*r;	
	}
	//成员方法中直接访问成员属性　和　成员方法
	void show(){
		cout << "我是一个半径为:"<< r << "的圆，面积为:"<<area() << "，周长为:"<< len() << endl;	
	}
};


int main(){
	Circle c;
	c.setR(2);
	//cout << c.getR() << "," << c.area() << "," << c.len() << endl;
	c.show();
	Circle cir(4);
	//cout << cir.getR() << "," << cir.area() << "," << cir.len() << endl;
	cir.show();
	return 0;	
}

Circle c; – 创建对象c 调用无参的构造函数 Circle()
Circle cir(); – 函数声明 声明一个返回Circle类型的函数，没有形参
– cir是函数，不是Circle对象

7.对象、属性和函数(方法)

成员函数(方法)里面可以访问属性(成员变量)，也可以直接调用其它的成员函数
在类外面只能访问public的属性和方法，而且必须通过
对象.属性
对象.函数名(实参列表);

8.对象的构造过程

先分配内存—>调用构造函数—>调用类类型成员的构造函数进行构造成员—>执行构造函数体

9. 栈 和 堆里对象

Circle c;
Circle c();//不是创建对象
Circle *pc = new Circle();
Circle *pc = new Circle;

注意：
new申请类类型成员对象时 会调用构造函数 而 malloc则不会；

#include <iostream>
#include <cstdlib>
using namespace std;

//平面坐标点类
class Point{
private:
	double x;
	double y;
public:
	Point(double x1,double y1){
		x = x1;
		y = y1;
	}
	//一般来说都会手动提供无参的构造函数 以防止
	Point(){
		cout << "Point()构造函数" << endl;
		x = 0;
		y = 0;
	}
};

//平面圆类
class Circle{
private:
	Point center;
	double r;
	//默认生成的无参构造函数　对于基本数据类型　不会做初始化
	//但是对于类类型成员　会调用其类型的　无参构造函数
public:
	Circle(){//先构造成员对象center  调用Point类的构造函数
		cout << "Circle()构造函数" << endl;				
	}
	void show(){
		
	}
};

int main(){
	//Point p(0,0);
	Circle c;//分配内存　调用Circle的构造函数   Circle()
	//注意:
	Circle cir();//cir是Circle类的对象吗?  不是的
	//函数声明　　即声明了一个函数　该函数返回一Circle类型的对象，没有任何形参
	//cir.show();  cir是一个函数　不是一个对象
	cout << "----- "<<endl;
	Circle *pc1 = new Circle;//调用构造函数　创建对象
	Circle *pc2 = new Circle();//调用构造函数　创建对象
	delete pc1;
	delete pc2;
	cout << "----------------" << endl;
	Circle *pc3 = static_cast<Circle*>(malloc(sizeof(Circle)));//malloc不会调用构造函数

	return 0;	
}