C++面向对象编程：从零开始构建类与对象（上）

在 C++ 的世界里，类和对象是实现面向对象编程（OOP）的核心概念。面向对象编程通过封装、继承和多态三大特性，使得代码更易于维护、扩展和复用。本篇文章将带你从零开始，深入理解 C++ 中类和对象的概念，并通过具体的代码示例，让你彻底掌握它们的使用方法。

类：定义对象的蓝图

类（Class）可以看作是创建对象的蓝图或模板。它定义了对象所具有的属性（成员变量）和行为（成员函数）。例如，我们可以定义一个 Dog 类，它有 name（名字）、age（年龄）和 breed（品种）等属性，以及 bark（叫）、eat（吃）和 sleep（睡）等行为。

声明和定义类

在 C++ 中，使用 class 关键字来声明一个类。类的定义通常包含在头文件（.h 或 .hpp）中，而成员函数的实现则放在源文件（.cpp）中。

// Dog.h
#ifndef DOG_H
#define DOG_H

#include <string>

class Dog {
private:
    std::string name;  // 名字
    int age;          // 年龄
    std::string breed; // 品种

public:
    // 构造函数
    Dog(std::string name, int age, std::string breed);

    // 成员函数
    void bark();
    void eat(std::string food);
    void sleep();

    // Getter 函数
    std::string getName() const;
    int getAge() const;
    std::string getBreed() const;

    // Setter 函数
    void setName(std::string name);
    void setAge(int age);
    void setBreed(std::string breed);
};

#endif

在上面的代码中，我们声明了一个 Dog 类。private 关键字表示私有成员，只能在类内部访问；public 关键字表示公共成员，可以在类的外部访问。这种封装性是面向对象编程的重要特性之一。Dog(std::string name, int age, std::string breed); 是构造函数，用于初始化类的对象。

实现成员函数

成员函数的实现在源文件中进行。我们需要使用作用域解析运算符 :: 来指定函数属于哪个类。

// Dog.cpp
#include "Dog.h"
#include <iostream>

Dog::Dog(std::string name, int age, std::string breed) : name(name), age(age), breed(breed) {}

void Dog::bark() {
    std::cout << "Woof! Woof!" << std::endl;
}

void Dog::eat(std::string food) {
    std::cout << name << " is eating " << food << std::endl;
}

void Dog::sleep() {
    std::cout << name << " is sleeping" << std::endl;
}

std::string Dog::getName() const {
    return name;
}

int Dog::getAge() const {
    return age;
}

std::string Dog::getBreed() const {
    return breed;
}

void Dog::setName(std::string name) {
    this->name = name;
}

void Dog::setAge(int age) {
    this->age = age;
}

void Dog::setBreed(std::string breed) {
    this->breed = breed;
}

对象：类的实例

对象（Object）是类的实例。我们可以使用类来创建多个对象，每个对象都拥有类定义的属性和行为。例如，我们可以创建两个 Dog 对象：dog1 和 dog2，它们分别代表不同的狗。

创建和使用对象

// main.cpp
#include "Dog.h"
#include <iostream>

int main() {
    Dog dog1("Buddy", 3, "Golden Retriever"); // 创建 Dog 对象 dog1
    Dog dog2("Lucy", 5, "Labrador");          // 创建 Dog 对象 dog2

    dog1.bark();        // 调用 dog1 的 bark 函数
    dog2.eat("bone");   // 调用 dog2 的 eat 函数

    std::cout << dog1.getName() << " is a " << dog1.getBreed() << std::endl;

    return 0;
}

运行上面的代码，你会看到以下输出：

Woof! Woof!
Lucy is eating bone
Buddy is a Golden Retriever

指针对象和堆内存

除了像上面那样直接在栈上创建对象之外，我们还可以使用 new 关键字在堆上创建对象。需要注意的是，在堆上创建的对象需要手动使用 delete 释放内存，否则会造成内存泄漏。

Dog* dog3 = new Dog("Max", 2, "German Shepherd");
dog3->bark(); // 使用 -> 访问成员函数

delete dog3;  // 释放内存
dog3 = nullptr; //避免野指针

类的访问控制：Public, Private 和 Protected

C++ 提供了三种访问控制修饰符：public、private 和 protected。public 成员可以在类的外部访问，private 成员只能在类的内部访问，而 protected 成员可以在类的内部以及子类中访问。合理使用访问控制修饰符可以提高代码的封装性和安全性。在实际项目中，通常会将成员变量设置为 private，然后通过 public 的 getter 和 setter 函数来访问和修改它们，这是一种常见的实践。

在大型项目中，类和对象的设计至关重要。良好的类设计能够降低代码的耦合度，提高代码的可维护性。例如，在使用 Nginx 作为反向代理服务器时，我们可以将 Nginx 的配置参数封装成一个类，然后通过修改类的属性来动态调整 Nginx 的配置。这比直接修改 Nginx 的配置文件更加安全和方便。此外，我们还可以使用宝塔面板等工具来简化 Nginx 的配置和管理。

关于C++类和对象的更多特性，我们将在下篇文章中继续深入探讨，包括继承、多态等高级概念。