C++ 类和对象入门：从定义到使用一篇讲清楚

Fairly gentleman596

562人浏览 · 2026-05-06 08:30:00

Fairly gentleman596 · 2026-05-06 08:30:00 发布

在学习 C++ 的过程中，类和对象几乎是每个初学者都会遇到的核心内容。很多人第一次接触它们时，都会觉得这些概念有点抽象：什么是类？什么又是对象？它们和普通变量、函数到底有什么区别？

其实，类和对象并没有想象中那么难。你可以把“类”理解为一张设计图纸，把“对象”理解为按照这张图纸制造出来的具体实物。图纸规定了这个事物应该有哪些属性、能做哪些事情，而对象则是根据这个规则真正创建出来的实例。理解了这一点，后面很多内容都会顺畅很多。

这篇文章就来系统讲清楚 C++ 中的类和对象，包括它们的基本概念、定义方式、访问权限、构造函数以及常见问题。希望你看完之后，不仅知道语法怎么写，更知道为什么要这样写。

为什么需要类和对象

在学习类和对象之前，我们先思考一个问题：为什么程序里需要它们？

如果只是写一些简单程序，比如输入两个数字然后求和，或者输出一个九九乘法表，那么用普通变量和函数就完全够了。但是，当程序变得越来越复杂时，我们需要表示的“事物”也会越来越多。比如学生、汽车、图书、商品、银行账户，这些东西都有自己的属性和行为。

举个简单例子，如果我们想在程序中表示一个学生，那么至少要有这些信息：

姓名
年龄
学号

除此之外，这个学生还可能有一些行为：

显示个人信息
修改年龄
修改姓名

如果你只是用一堆零散的变量来表示这些内容，比如：

string name = "Tom";
int age = 20;
int id = 1001;

那么当程序里有 10 个学生、100 个学生时，这种写法就会变得非常混乱。你很难清楚地管理“哪些数据属于哪个学生”，也不容易把“学生能做什么”统一组织起来。

这时候，类的价值就体现出来了。类可以把一类事物的“属性”和“行为”封装在一起，让程序结构更清晰，也更符合现实世界中的思维方式。

所以，从本质上说，类和对象的出现，是为了让程序能够更自然地描述现实中的事物，并且更方便地组织复杂代码。

1. 什么是类

类可以理解为一种自定义的数据类型。它不是 C++ 语言内置的 int、double、char 这类基础类型，而是程序员根据需要自己设计出来的类型。

比如我们可以定义一个 Student 类，专门用来表示学生。这个类中可以包含：

学生有哪些属性，比如姓名、年龄、学号
学生有哪些行为，比如显示信息、修改信息

也就是说，类是对“一类事物”的抽象描述。

在 C++ 中，定义类要使用 class 关键字。类中可以包含成员变量和成员函数，前者表示属性，后者表示行为。例如，我们可以定义一个 Student 类，里面保存学生的姓名和年龄，并提供一个输出信息的函数。

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

class Student {
public:
    string name;
    int age;

    void show() {
        cout << "姓名：" << name << "，年龄：" << age << endl;
    }
};

在这个例子中，Student 是类名，name 和 age 是成员变量，show() 是成员函数。类本身还不是具体对象，它只是一个模板或蓝图。

2. 什么是对象

类定义好以后，就可以创建对象。对象的创建方式和声明普通变量有些类似，只不过类型变成了你自己定义的类。对象是根据类创建出来的具体实例。

比如你定义了一个 Student 类，那么可以创建出 stu1、stu2、stu3 等多个对象。它们都属于 Student 类，但每个对象保存的数据可以不同。

你可以这样理解：

类是模板
对象是根据模板创建出来的具体实例

比如“学生”是一个抽象概念，而“张三”“李四”则是具体的学生对象。

Student s1;
s1.name = "Tom";
s1.age = 20;
s1.show();

这里的 s1 就是一个对象，也可以说是 Student 类的一个实例。当我们创建多个对象时，它们都会拥有相同的成员函数，但成员变量的值可以各不相同。

如果还是觉得抽象，可以记住下面这个类比：

类 = 图纸
对象 = 按照图纸造出来的房子

图纸规定了房子应该有客厅、卧室、厨房；而根据这张图纸，可以建很多栋具体的房子。每栋房子的结构类似，但里面的摆设、颜色、位置可以不同。

这正好对应了程序中的类和对象。

如何定义一个类

在 C++ 中，定义类需要使用 class 关键字。基本语法如下：

class 类名 {
public:
    成员变量;
    成员函数;
};

这里的“成员变量”表示属性，“成员函数”表示行为。

下面我们来定义一个最简单的学生类：

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

class Student {
public:
    string name;
    int age;

    void show() {
        cout << "姓名：" << name << "，年龄：" << age << endl;
    }
};

这个类包含两个成员变量：

name：表示学生姓名
age：表示学生年龄

还包含一个成员函数：

show()：用于输出学生信息

这里要注意一点：类只是定义，还没有真正创建学生。它只是告诉编译器，以后如果要表示“学生”，就按这个结构来。

如何创建对象并使用对象

类定义好之后，就可以根据这个类创建对象。

创建对象的语法和定义普通变量有点像：

类名 对象名;

比如：

Student s1;

这表示创建了一个 Student 类型的对象 s1。

创建完对象之后，就可以通过“点运算符” . 来访问对象中的成员变量和成员函数：

s1.name = "Tom";
s1.age = 20;
s1.show();

完整代码如下：

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

class Student {
public:
    string name;
    int age;

    void show() {
        cout << "姓名：" << name << "，年龄：" << age << endl;
    }
};

int main() {
    Student s1;
    s1.name = "Tom";
    s1.age = 20;
    s1.show();

    return 0;
}

运行结果：

姓名：Tom，年龄：20

这就是最基础的类和对象使用方式。

一个类可以创建多个对象

类最大的意义之一，就是可以创建多个对象。

比如我们继续使用 Student 类，就可以创建多个学生对象：

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

class Student {
public:
    string name;
    int age;

    void show() {
        cout << "姓名：" << name << "，年龄：" << age << endl;
    }
};

int main() {
    Student s1;
    s1.name = "Tom";
    s1.age = 20;

    Student s2;
    s2.name = "Alice";
    s2.age = 22;

    s1.show();
    s2.show();

    return 0;
}

运行结果：

姓名：Tom，年龄：20
姓名：Alice，年龄：22

这里你会发现，s1 和 s2 都属于 Student 类，它们拥有相同的成员函数 show()，但是它们的数据彼此独立。s1 的姓名和年龄不会影响 s2，反过来也一样。

这说明：对象虽然来自同一个类，但每个对象都有自己独立的数据空间。

3. public 和 private 是什么

在类中，常见的访问控制符有 public、private 和 protected，其中初学阶段最重要的是前两个。 public 成员可以在类的外部访问，而 private 成员只能在类的内部访问，这样可以起到封装和保护数据的作用。

例如下面这种写法就更规范：

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

class Student {
private:
    string name;
    int age;

public:
    void setInfo(string n, int a) {
        name = n;
        age = a;
    }

    void show() {
        cout << "姓名：" << name << "，年龄：" << age << endl;
    }
};

这时，外部不能直接写 s1.name = "Tom"，而是需要通过公开的成员函数去修改数据。这就是封装思想的基础：隐藏内部实现，只暴露必要接口。

为什么要有 private

很多初学者会觉得：既然 public 更方便，那为什么还要有 private？

答案是：为了保护数据，避免对象被随意修改。

举个例子，如果年龄可以随便改成负数，那显然是不合理的。通过把成员变量设为 private，我们就可以控制外部如何修改它，从而保证数据更安全。

这就是封装思想的一部分：隐藏内部细节，只暴露必要接口。

4. 构造函数有什么用

当对象被创建时，构造函数会自动调用，它的主要作用是初始化对象的成员变量。对初学者来说，可以把它理解成“对象出生时自动执行的一段初始化代码”。

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

class Student {
private:
    string name;
    int age;

public:
    Student(string n, int a) {
        name = n;
        age = a;
    }

    void show() {
        cout << "姓名：" << name << "，年龄：" << age << endl;
    }
};

使用时就可以直接这样创建对象：

int main() {
    Student s1("Alice", 19);
    s1.show();
    return 0;
}

这种写法比先创建对象、再逐个赋值更自然，也更符合面向对象的使用方式。

5. 一个完整示例

下面给出一个更完整的例子，把类、对象、封装和构造函数串起来：

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

class Person {
private:
    string name;
    int age;

public:
    Person(string n, int a) {
        name = n;
        age = a;
    }

    void sayHello() {
        cout << "大家好，我叫" << name << "，今年" << age << "岁。" << endl;
    }
};

int main() {
    Person p1("张三", 18);
    Person p2("李四", 20);

    p1.sayHello();
    p2.sayHello();

    return 0;
}

这个程序中，Person 是类，p1 和 p2 是对象。它们都来自同一个类，所以有相同的行为 sayHello()，但保存的是各自不同的数据。