C++类与对象（1）

类（Class）

类是C++中的一个用户定义的数据类型，它定义了一组属性（数据成员）和方法（成员函数），用于表示和操作一类实体的共有特征。类是描述对象的蓝图或模板。在C++中，类的定义是创建自定义数据类型的一种方式，它由一组成员变量（数据成员）和成员函数（方法）组成。下面将详细介绍类的定义，包括语法、访问控制、构造函数与析构函数、成员函数、友元函数等内容。

1. 类的基本语法

class ClassName {  
public: // 访问控制  
    // 数据成员  
    DataType memberVariable;  

    // 构造函数  
    ClassName(parameters);  

    // 成员函数  
    ReturnType memberFunction(parameters);  
    
private: // 访问控制  
    // 私有数据成员或成员函数  

protected: // 访问控制  
    // 保护数据成员或成员函数  
};

2. 访问控制

C++中的类提供了三种访问控制修饰符：

• public：公共成员，可以被任何其他代码访问。
• private：私有成员，仅可以在类内部访问，外部无法直接访问。
• protected：保护成员，可以在类内部和派生类中访问，但在外部无法直接访问。
• 示例：

  class Example {  
  public:  
      int publicVar; // 公有成员  
  private:  
      int privateVar; // 私有成员  
  protected:  
      int protectedVar; // 保护成员  
  };

3. 数据成员

数据成员是类的属性，用于存储对象的状态。可以是基本数据类型、结构体、类的实例或其他复杂类型。

示例：

class Person {  
public:  
    std::string name; // 姓名  
    int age; // 年龄  
};

4. 构造函数与析构函数

• 构造函数：用于初始化对象的特殊成员函数，名称与类名相同, 可以重载。构造函数可以接受参数，也可以是默认构造函数（无参数构造函数）。

• 析构函数：用于清理对象并释放资源的特殊成员函数，名称与类名相同，但前面加上波浪符 ~。析构函数无法重载，并且不能带参数。

示例：

class Car {  
public:  
    std::string brand;  
    int year;  

    // 构造函数  
    Car(std::string b, int y) : brand(b), year(y) {  
        std::cout << "Car created: " << brand << " " << year << std::endl;  
    }  

    // 析构函数  
    ~Car() {  
        std::cout << "Car destroyed: " << brand << " " << year << std::endl;  
    }  
};

5. 成员函数

成员函数是类内定义的函数，用于对成员变量进行操作。成员函数可以修改类的私有成员，在类外部通过对象调用时可以访问公共成员。

示例：

class Rectangle {  
private:  
    double width, height;  

public:  
    Rectangle(double w, double h) : width(w), height(h) {}  

    double area() {  
        return width * height; // 计算面积  
    }  
};

6. 友元函数

友元函数是可以访问类的私有和保护成员的函数，即使它不是该类的成员。可以将其声明为友元，以实现特定需要。

示例：

class Box {  
private:  
    double width;  

public:  
    Box(double w) : width(w) {}  

    friend void printWidth(Box b); // 声明友元函数  
};  

void printWidth(Box b) {  
    std::cout << "Width: " << b.width << std::endl; // 访问私有成员  
}

7. 完整示例

将上述所有内容结合起来，我们可以定义一个完整的类：

#include <iostream>  
#include <string>  

class Car {  
private:  
    std::string brand;  
    int year;  

public:  
    // 构造函数  
    Car(std::string b, int y) : brand(b), year(y) {}  

    // 成员函数  
    void displayInfo() {  
        std::cout << "Brand: " << brand << ", Year: " << year << std::endl;  
    }  

    // 友元函数  
    friend void showBrand(Car c);  
};  

// 友元函数实现  
void showBrand(Car c) {  
    std::cout << "Brand from friend function: " << c.brand << std::endl;  
}  

int main() {  
    Car myCar("Toyota", 2020);  
    myCar.displayInfo();  
    showBrand(myCar); // 调用友元函数  
    return 0;  
}

8.基本特性

1.封装：

封装是将数据和操作数据的函数（方法）组合在一起，通过将数据的具体实现细节隐藏在类内部，保持类的内部状态独立于外部世界。封装使用访问控制修饰符（public、private、protected）来限定对类成员的访问。

优点：

• 数据保护：防止未经授权的访问和修改。
• 易于维护：内部实现可以修改而不影响外部代码。

示例：

class BankAccount {  
private:  
    double balance; // 私有数据成员  

public:  
    BankAccount(double initialBalance) : balance(initialBalance) {}  

    void deposit(double amount) {  
        if (amount > 0) {  
            balance += amount; // 允许访问私有成员  
        }  
    }  

    double getBalance() const {  
        return balance; // 可以读取余额，但不允许直接修改  
    }  
};

2.抽象：

继承是一个类（子类）基于另一个类（父类）创建新类的机制，使得子类可以继承父类的属性和方法。通过继承，子类可以重用代码，扩展功能，以及更好地组织相关的实体。

优点：

• 代码重用：子类可以使用父类的成员。
• 形成类之间的层次结构，增强可扩展性。

示例：

class Animal {  
public:  
    void eat() {  
        std::cout << "Eating..." << std::endl;  
    }  
};  

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

int main() {  
    Dog dog;  
    dog.eat(); // 继承的功能  
    dog.bark(); // 子类特有的功能  
    return 0;  
}

3.继承：

多态是指同一操作可以作用于不同类型的对象，表现出不同的行为。C++ 通过虚函数和函数重载实现多态性。多态可以分为编译时多态（函数重载和运算符重载）和运行时多态（通过虚函数实现）。

优点：

• 灵活性：同一接口可以产生不同的行为。
• 可扩展性：可以在不更改现有代码的情况下添加新功能。

示例：

class Base {  
public:  
    virtual void show() { // 虚函数  
        std::cout << "Base class show function." << std::endl;  
    }  
};  

class Derived : public Base {  
public:  
    void show() override { // 重写虚函数  
        std::cout << "Derived class show function." << std::endl;  
    }  
};  

void display(Base* b) {  
    b->show(); // 根据对象类型调用相应的函数  
}  

int main() {  
    Base base;  
    Derived derived;  
    display(&base); // 输出: Base class show function.  
    display(&derived); // 输出: Derived class show function.  
    return 0;  
}

4.抽象：

抽象是一个简化过程，它使得只关注对象的必要特征而忽略不相关的细节。通过抽象，可以设计出更高层次的结构，提供简单的接口，将复杂性封装在内部。

抽象可以通过纯虚函数和抽象类来实现。一个类如果包含一个或多个纯虚函数，则称为抽象类，该类无法被实例化。

优点：

• 隐藏复杂性：提供简单的接口，用户无需了解内部细节。
• 支持模块化设计：增强代码的可维护性和可读性。

示例：

class Shape {  
public:  
    virtual void draw() = 0; // 纯虚函数  
};  

class Circle : public Shape {  
public:  
    void draw() override {  
        std::cout << "Drawing a circle." << std::endl;  
    }  
};  

class Square : public Shape {  
public:  
    void draw() override {  
        std::cout << "Drawing a square." << std::endl;  
    }  
};  

int main() {  
    Circle circle;  
    Square square;  

    Shape* shapes[] = { &circle, &square };  
    
    for (Shape* shape : shapes) {  
        shape->draw(); // 根据具体形状调用相应的 draw 方法  
    }  

    return 0;  
}

9.总结

类的定义涉及到成员变量、成员函数、构造函数、析构函数和访问修饰符等各个方面。理解这些概念是掌握C++面向对象编程的基础，有助于设计和实现高效、可维护的代码结构。类的四个基本特征（封装、继承、多态、抽象）共同构成了面向对象编程的核心思想，帮助开发者构建模块化、易于维护和扩展的系统。理解这些特性，可以有效地运用C++进行复杂的应用开发。