类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例（Instance），拥有类的成员变量和成员函数。
一.类的定义
一个简单的类的定义：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
class Student{
public:
//成员变量
char *name;
int age;
float score;
//成员函数
void say(){
cout<<name<<"的年龄是"<<age<<"，成绩是"<<score<<endl;
}
};
|
class是 C++ 中新增的关键字，专门用来定义类。Student是类的名称；类名的首字母一般大写，以和其他的标识符区分开。{ }内部是类所包含的成员变量和成员函数，它们统称为类的成员（Member）；由{ }包围起来的部分有时也称为类体，和函数体的概念类似。
注意：在类定义的最后有一个分号;，它是类定义的一部分，表示类定义结束了，不能省略。
类只是一个模板（Template），编译后不占用内存空间，所以在定义类时不能对成员变量进行初始化，因为没有地方存储数据。只有在创建对象以后才会给成员变量分配内存，这个时候就可以赋值了。
二.创建对象并访问类的成员
创建对象的方式如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
#include <iostream>
using namespace std;
//类通常定义在函数外面
class Student{
public:
//类包含的变量
char *name;
int age;
float score;
//类包含的函数
void say(){
cout<<name<<"的年龄是"<<age<<"，成绩是"<<score<<endl;
}
};
int main(){
//创建对象
Student stu;
stu.name = "小明";
stu.age = 15;
stu.score = 92.5f;
stu.say();
return 0;
}
|
运行结果：
小明的年龄是15，成绩是92.5
stu 是一个对象，占用内存空间，因此可以对它的成员变量赋值，也可以读取它的成员变量。类通常定义在函数外面，当然也可以定义在函数内部，不过很少这样使用。
三.使用对象指针
C语言中经典的指针在 C++ 中仍然广泛使用，尤其是指向对象的指针，没有它就不能实现某些功能。
上面代码中创建的对象 stu 在栈上分配内存，需要使用&获取它的地址，例如：
Student stu;
Student *pStu = &stu;
pStu 是一个指针，它指向 Student 类型的数据，也就是通过 Student 创建出来的对象。
同样，也可以在堆区创建对象，此时就要用到new关键字：
Student *pStu = new Student;
如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
#include <iostream>
using namespace std;
class Student {
public:
char *name;
int age;
float score;
void say() {
cout << name << ",age is " << age << ",score is " << score << endl;
}
};
int main()
{
// Student stu;
// stu.name = "JACK";
// stu.age = 15;
// stu.score = 92.5f;
// stu.say();
// Student stu; // 在栈区创建对象
// Student *pStu = &stu;
Student *pStu = new Student; // 在堆区创建对象
pStu ->name = "Jack";
pStu -> age = 10;
pStu -> score = 92.5f;
pStu -> say();
delete pStu; // 删除对象
return 0;
}
|
注意：在栈上创建出来的对象都有一个名字，比如 stu，因此使用指针指向它不是必须的。但是通过 new 创建出来的对象就不一样了，它在堆上分配内存，没有名字，只能得到一个指向它的指针，所以必须使用一个指针变量来接收这个指针，否则以后再也无法找到这个对象了，更没有办法使用它。
也就是说，使用 new 在堆上创建出来的对象是匿名的，没法直接使用，必须要用一个指针指向它，再借助指针来访问它的成员变量或成员函数。
栈内存是程序自动管理的，不能使用 delete 删除在栈上创建的对象；堆内存由程序员管理，对象使用完毕后可以通过 delete 删除。在实际开发中，new 和 delete 往往成对出现，以保证及时删除不再使用的对象，防止无用内存堆积。
下面是其它网友的补充
C++学习初级知识点整理之类和对象基础篇
1.如何定义类？
class Tv
{
public:
void change_vol();
void power();
//private:
int type;
char name[20];
}
2.对象的实例化
定义：即在IDE中由一个类生成多个对象的过程。
格式：类名 对象名；
例：Tv s;
两种方法：
ps:栈空间：保存局部变量、自动变量、函数形参。
特点是先进先出，由系统管理内存。
堆空间：由malloc、new，等空间分配函数申请的空间
特点是先进后出、由用户管理（释放）
a.从栈中实例化对象： b.从堆中实例化对象：
int main() int main()
{ {
Tv tv; Tv *p = new tv; //从堆中申请内存，用完释放
Tv tv[20]; Tv *q = new tv[20];
...... ......
return 0; //栈空间由系统释放 delelte p; //释放指针所指向内存空间
} delete []q;
p = NULL; // 将指针指向空
q = NULL;
return 0;
}
3.对象成员的访问
a.对栈中的对象成员访问
int main()
{Tv tv;
tv.type = 0;
tv.change_vol();
return 0;
}
b.对堆中的对象进行访问
单个对象： 对象数组：
int main(void) int main(void)
{ {
Tv *p = new tv; // new 分配空间 Tv *p = new tv[5];
p->type = 0; for (int i = 0; i < 5; i++)
p->change_vol(); {
delete p; //使用完毕，释放内存 p[i]->type = 0;
p = NULL; //将指针Ｐ指向空 p[i]->change_vol();
return 0; }
} delete []p;
p = NULL;
return 0;
}
关于类在内存中的储存：类在定义时，并不会在堆或者栈中分配内存空间，只有在它实例化一个对象时，对象的成员变量会在栈上分配内存空间，成员函数还是在代码段。当同一个实例化多个对象时，每个对象的成员变量会在栈上分配不同的内存空间，但是多个对象通过对应的接口公用一个代码段的成员函数。
原文链接：https://www.cnblogs.com/yongdaimi/p/7054451.html