C++语言教程

Appearance

C++ 类 & 对象 ​

类（class）是 C++ 中面向对象编程的核心概念，它是一种用户自定义的数据类型，封装了数据（成员变量）和操作数据的方法（成员函数）。

1. 类的定义 ​

1.1 基本语法 ​

cpp
class 类名 {
private:
    // 私有成员变量和成员函数
protected:
    // 保护成员变量和成员函数
public:
    // 公有成员变量和成员函数
};

示例 ​

cpp
#include <iostream>

class Student {
private:
    std::string name;
    int age;
    float gpa;

public:
    // 构造函数
    Student() : name(""), age(0), gpa(0.0f) {}
    
    // 带参数的构造函数
    Student(std::string name, int age, float gpa) : name(name), age(age), gpa(gpa) {}
    
    // 成员函数
    void set_name(std::string name) {
        this->name = name;
    }
    
    std::string get_name() {
        return name;
    }
    
    void set_age(int age) {
        this->age = age;
    }
    
    int get_age() {
        return age;
    }
    
    void set_gpa(float gpa) {
        this->gpa = gpa;
    }
    
    float get_gpa() {
        return gpa;
    }
    
    void print() {
        std::cout << "姓名: " << name << std::endl;
        std::cout << "年龄: " << age << std::endl;
        std::cout << "GPA: " << gpa << std::endl;
    }
};

int main() {
    // 创建对象
    Student student1;
    student1.set_name("张三");
    student1.set_age(20);
    student1.set_gpa(3.8f);
    student1.print();
    
    std::cout << std::endl;
    
    // 使用带参数的构造函数创建对象
    Student student2("李四", 21, 3.5f);
    student2.print();
    
    return 0;
}

2. 访问修饰符 ​

2.1 public ​

public成员可以在任何地方被访问。

cpp
#include <iostream>

class Point {
public:
    int x;
    int y;
    
    void print() {
        std::cout << "x = " << x << ", y = " << y << std::endl;
    }
};

int main() {
    Point point;
    point.x = 10;
    point.y = 20;
    point.print();
    
    return 0;
}

2.2 private ​

private成员只能在类内部被访问。

cpp
#include <iostream>

class Point {
private:
    int x;
    int y;

public:
    void set_x(int x) {
        this->x = x;
    }
    
    void set_y(int y) {
        this->y = y;
    }
    
    void print() {
        std::cout << "x = " << x << ", y = " << y << std::endl;
    }
};

int main() {
    Point point;
    point.set_x(10);
    point.set_y(20);
    point.print();
    
    return 0;
}

2.3 protected ​

protected成员可以在类内部和派生类中被访问。

cpp
#include <iostream>

class Base {
protected:
    int x;

public:
    Base() : x(0) {}
    
    void set_x(int x) {
        this->x = x;
    }
    
    int get_x() {
        return x;
    }
};

class Derived : public Base {
public:
    void increment_x() {
        x++;  // 可以访问 protected 成员
    }
};

int main() {
    Derived derived;
    derived.set_x(10);
    derived.increment_x();
    std::cout << "x = " << derived.get_x() << std::endl;
    
    return 0;
}

3. 构造函数和析构函数 ​

3.1 构造函数 ​

构造函数是一种特殊的成员函数，用于初始化对象。

cpp
#include <iostream>

class Student {
private:
    std::string name;
    int age;

public:
    // 默认构造函数
    Student() : name(""), age(0) {
        std::cout << "默认构造函数被调用" << std::endl;
    }
    
    // 带参数的构造函数
    Student(std::string name, int age) : name(name), age(age) {
        std::cout << "带参数的构造函数被调用" << std::endl;
    }
    
    // 拷贝构造函数
    Student(const Student& other) : name(other.name), age(other.age) {
        std::cout << "拷贝构造函数被调用" << std::endl;
    }
    
    void print() {
        std::cout << "姓名: " << name << ", 年龄: " << age << std::endl;
    }
};

int main() {
    Student student1;
    Student student2("张三", 20);
    Student student3 = student2;
    
    student1.print();
    student2.print();
    student3.print();
    
    return 0;
}

3.2 析构函数 ​

析构函数是一种特殊的成员函数，用于清理对象。

cpp
#include <iostream>

class Student {
private:
    std::string name;
    int age;

public:
    Student(std::string name, int age) : name(name), age(age) {
        std::cout << "构造函数被调用" << std::endl;
    }
    
    ~Student() {
        std::cout << "析构函数被调用" << std::endl;
    }
    
    void print() {
        std::cout << "姓名: " << name << ", 年龄: " << age << std::endl;
    }
};

int main() {
    Student student("张三", 20);
    student.print();
    
    return 0;
}

4. 成员函数 ​

4.1 在类内部定义成员函数 ​

cpp
#include <iostream>

class Point {
private:
    int x;
    int y;

public:
    Point(int x, int y) : x(x), y(y) {}
    
    void print() {
        std::cout << "x = " << x << ", y = " << y << std::endl;
    }
};

int main() {
    Point point(10, 20);
    point.print();
    
    return 0;
}

4.2 在类外部定义成员函数 ​

cpp
#include <iostream>

class Point {
private:
    int x;
    int y;

public:
    Point(int x, int y);
    void print();
};

Point::Point(int x, int y) : x(x), y(y) {}

void Point::print() {
    std::cout << "x = " << x << ", y = " << y << std::endl;
}

int main() {
    Point point(10, 20);
    point.print();
    
    return 0;
}

5. this 指针 ​

this指针是指向当前对象的指针。

cpp
#include <iostream>

class Point {
private:
    int x;
    int y;

public:
    Point(int x, int y) {
        this->x = x;
        this->y = y;
    }
    
    Point& set_x(int x) {
        this->x = x;
        return *this;
    }
    
    Point& set_y(int y) {
        this->y = y;
        return *this;
    }
    
    void print() {
        std::cout << "x = " << x << ", y = " << y << std::endl;
    }
};

int main() {
    Point point(0, 0);
    point.set_x(10).set_y(20);
    point.print();
    
    return 0;
}

6. 静态成员 ​

6.1 静态成员变量 ​

静态成员变量是所有对象共享的变量。

cpp
#include <iostream>

class Counter {
private:
    static int count;

public:
    Counter() {
        count++;
    }
    
    ~Counter() {
        count--;
    }
    
    static int get_count() {
        return count;
    }
};

int Counter::count = 0;

int main() {
    std::cout << "count = " << Counter::get_count() << std::endl;
    
    Counter c1;
    std::cout << "count = " << Counter::get_count() << std::endl;
    
    Counter c2;
    std::cout << "count = " << Counter::get_count() << std::endl;
    
    {
        Counter c3;
        std::cout << "count = " << Counter::get_count() << std::endl;
    }
    
    std::cout << "count = " << Counter::get_count() << std::endl;
    
    return 0;
}

6.2 静态成员函数 ​

静态成员函数只能访问静态成员变量和静态成员函数。

cpp
#include <iostream>

class Math {
public:
    static int add(int a, int b) {
        return a + b;
    }
    
    static int subtract(int a, int b) {
        return a - b;
    }
    
    static int multiply(int a, int b) {
        return a * b;
    }
    
    static int divide(int a, int b) {
        return a / b;
    }
};

int main() {
    std::cout << "10 + 20 = " << Math::add(10, 20) << std::endl;
    std::cout << "10 - 20 = " << Math::subtract(10, 20) << std::endl;
    std::cout << "10 * 20 = " << Math::multiply(10, 20) << std::endl;
    std::cout << "20 / 10 = " << Math::divide(20, 10) << std::endl;
    
    return 0;
}

7. 友元函数 ​

友元函数可以访问类的私有成员。

cpp
#include <iostream>

class Point {
private:
    int x;
    int y;

public:
    Point(int x, int y) : x(x), y(y) {}
    
    friend void print_point(const Point& point);
};

void print_point(const Point& point) {
    std::cout << "x = " << point.x << ", y = " << point.y << std::endl;
}

int main() {
    Point point(10, 20);
    print_point(point);
    
    return 0;
}

8. 示例：综合运用 ​

现在，让我们看一个综合运用各种类和对象特性的例子：

cpp
#include <iostream>
#include <string>

class Student {
private:
    std::string name;
    int age;
    float gpa;
    static int count;

public:
    // 默认构造函数
    Student() : name(""), age(0), gpa(0.0f) {
        count++;
    }
    
    // 带参数的构造函数
    Student(std::string name, int age, float gpa) : name(name), age(age), gpa(gpa) {
        count++;
    }
    
    // 拷贝构造函数
    Student(const Student& other) : name(other.name), age(other.age), gpa(other.gpa) {
        count++;
    }
    
    // 析构函数
    ~Student() {
        count--;
    }
    
    // Setter 方法
    void set_name(std::string name) {
        this->name = name;
    }
    
    void set_age(int age) {
        this->age = age;
    }
    
    void set_gpa(float gpa) {
        this->gpa = gpa;
    }
    
    // Getter 方法
    std::string get_name() {
        return name;
    }
    
    int get_age() {
        return age;
    }
    
    float get_gpa() {
        return gpa;
    }
    
    // 静态成员函数
    static int get_count() {
        return count;
    }
    
    // 成员函数
    void print() {
        std::cout << "姓名: " << name << std::endl;
        std::cout << "年龄: " << age << std::endl;
        std::cout << "GPA: " << gpa << std::endl;
    }
    
    // 友元函数
    friend void print_student(const Student& student);
};

int Student::count = 0;

void print_student(const Student& student) {
    std::cout << "姓名: " << student.name << std::endl;
    std::cout << "年龄: " << student.age << std::endl;
    std::cout << "GPA: " << student.gpa << std::endl;
}

int main() {
    std::cout << "学生数量: " << Student::get_count() << std::endl;
    std::cout << std::endl;
    
    // 使用默认构造函数创建对象
    Student student1;
    student1.set_name("张三");
    student1.set_age(20);
    student1.set_gpa(3.8f);
    std::cout << "学生1:" << std::endl;
    student1.print();
    std::cout << "学生数量: " << Student::get_count() << std::endl;
    std::cout << std::endl;
    
    // 使用带参数的构造函数创建对象
    Student student2("李四", 21, 3.5f);
    std::cout << "学生2:" << std::endl;
    student2.print();
    std::cout << "学生数量: " << Student::get_count() << std::endl;
    std::cout << std::endl;
    
    // 使用拷贝构造函数创建对象
    Student student3 = student2;
    std::cout << "学生3:" << std::endl;
    student3.print();
    std::cout << "学生数量: " << Student::get_count() << std::endl;
    std::cout << std::endl;
    
    // 使用友元函数
    std::cout << "使用友元函数:" << std::endl;
    print_student(student1);
    
    return 0;
}

小结 ​

C++ 类和对象包括：

  1. 类的定义：

    • 基本语法：class 类名 { ... };
    • 成员变量和成员函数

  2. 访问修饰符：

    • public：可以在任何地方被访问
    • private：只能在类内部被访问
    • protected：可以在类内部和派生类中被访问

  3. 构造函数和析构函数：

    • 构造函数：用于初始化对象
    • 析构函数：用于清理对象

  4. 成员函数：

    • 在类内部定义成员函数
    • 在类外部定义成员函数

  5. this 指针：

    • 指向当前对象的指针

  6. 静态成员：

    • 静态成员变量：所有对象共享的变量
    • 静态成员函数：只能访问静态成员变量和静态成员函数

  7. 友元函数：

    • 可以访问类的私有成员

关键概念：

  • 类：用户自定义的数据类型
  • 对象：类的实例
  • 构造函数：用于初始化对象
  • 析构函数：用于清理对象
  • this 指针：指向当前对象的指针
  • 静态成员：所有对象共享的成员
  • 友元函数：可以访问类的私有成员

掌握类和对象是 C++ 面向对象编程的基础，在后续章节中，我们将学习 C++ 的继承。

Copyright © 2025-2026 京公网安备 11010102000001号 京ICP备2024078128号-1