跳到主要内容

C++ 类声明

引言​

在C++中，类是面向对象编程的基本构建块。它是数据和函数的集合，代表现实世界中的实体。类声明是定义这些实体特性和行为的第一步，是学习C++面向对象编程的基础。

通过本文，你将学习：

  • 类声明的基本语法
  • 访问修饰符的使用
  • 类成员（数据成员和成员函数）的声明
  • 类声明与定义的区别
  • 实际应用中的类声明案例

什么是类声明？​

类声明是告诉编译器一个特定类型的类存在，它包含哪些数据和函数，以及它们的访问权限。类声明为程序设计提供了蓝图，就像建筑师的设计图纸一样。

基本语法​

C++中类声明的基本语法如下：

class 类名 {
   访问修饰符:
      数据成员;
      成员函数;
};

其中：

  • class 是关键字
  • 类名 遵循C++标识符命名规则，通常首字母大写
  • 访问修饰符 控制对类成员的访问权限
  • 数据成员 是类的属性（变量）
  • 成员函数 是类的方法（函数）

访问修饰符​

C++提供了三种访问修饰符：

  1. public: 可以被任何函数访问
  2. private: 只能被类的成员函数访问
  3. protected: 可以被类的成员函数和派生类访问
提示

如果不指定访问修饰符，类中的成员默认为private。

简单的类声明示例​

下面是一个简单的Student类声明：

class Student {
public:
    // 公有成员函数
    void setName(string n);
    string getName();
    void setAge(int a);
    int getAge();

private:
    // 私有数据成员
    string name;
    int age;
};

声明数据成员​

数据成员是类的变量，用于存储类的状态信息。

class Rectangle {
private:
    double length;   // 长度
    double width;    // 宽度
    
public:
    // 成员函数声明将在后面介绍
};

数据成员的特点​

  1. 封装性：通常声明为私有，通过公有方法访问
  2. 持久性：对象存在期间，数据成员一直存在
  3. 类型多样性：可以是基本类型、指针、引用或其他类的对象

声明成员函数​

成员函数是类的函数，用于操作类的数据成员，实现类的行为。

class Circle {
private:
    double radius;
    
public:
    // 构造函数
    Circle();
    Circle(double r);
    
    // 普通成员函数
    double getArea();
    double getPerimeter();
    
    // 设置和获取属性的函数
    void setRadius(double r);
    double getRadius();
};

成员函数的声明与定义分离​

C++允许将类的声明和成员函数的定义分开：

// 类声明部分
class Time {
private:
    int hour;
    int minute;
    int second;
    
public:
    Time();  // 默认构造函数
    void setTime(int h, int m, int s);
    void printTime();
};

// 成员函数定义部分
Time::Time() {
    hour = 0;
    minute = 0;
    second = 0;
}

void Time::setTime(int h, int m, int s) {
    hour = (h >= 0 && h < 24) ? h : 0;
    minute = (m >= 0 && m < 60) ? m : 0;
    second = (s >= 0 && s < 60) ? s : 0;
}

void Time::printTime() {
    cout << hour << ":" << minute << ":" << second << endl;
}

内联成员函数​

如果在类声明中直接定义成员函数，则该函数自动成为内联函数：

class Counter {
private:
    unsigned int count;
    
public:
    // 内联成员函数
    Counter() { count = 0; }
    
    void increment() { count++; }
    
    unsigned int getCount() { return count; }
};

构造函数和析构函数的声明​

构造函数和析构函数是特殊的成员函数，分别在对象创建和销毁时自动调用：

class Person {
private:
    string* name;
    int age;
    
public:
    // 构造函数
    Person();                     // 默认构造函数
    Person(string n, int a);      // 带参数构造函数
    Person(const Person& p);      // 复制构造函数
    
    // 析构函数
    ~Person();
    
    // 其他成员函数
    void display();
};

类声明中的静态成员​

静态成员属于类而非对象，所有对象共享一个静态成员副本：

class Account {
private:
    string accountNumber;
    double balance;
    
    static double interestRate;    // 静态数据成员
    static int accountCount;       // 静态数据成员
    
public:
    Account(string accNo, double bal);
    ~Account();
    
    static void setInterestRate(double rate);  // 静态成员函数
    static double getInterestRate();           // 静态成员函数
    static int getAccountCount();              // 静态成员函数
};
备注

静态数据成员通常需要在类外进行定义和初始化。

类声明中的常量成员函数​

常量成员函数承诺不会修改对象的状态：

class Date {
private:
    int day;
    int month;
    int year;
    
public:
    Date(int d, int m, int y);
    
    // 常量成员函数
    int getDay() const;
    int getMonth() const;
    int getYear() const;
    
    void setDate(int d, int m, int y);
};

类的前向声明​

当两个类相互引用时，可以使用前向声明：

// 前向声明
class B;

class A {
private:
    B* b;
public:
    void setB(B* ptr);
};

class B {
private:
    A* a;
public:
    void setA(A* ptr);
};

实际案例：银行账户系统​

下面是一个银行账户系统的类声明示例，展示了类声明在实际应用中的使用：

// 前向声明
class Transaction;

class BankAccount {
private:
    string accountNumber;
    string ownerName;
    double balance;
    vector<Transaction*> transactions;
    static double interestRate;

public:
    // 构造函数和析构函数
    BankAccount(string accNo, string name, double initialBalance);
    ~BankAccount();
    
    // 账户操作
    void deposit(double amount);
    bool withdraw(double amount);
    void transfer(BankAccount& target, double amount);
    
    // 账户信息
    string getAccountNumber() const;
    string getOwnerName() const;
    double getBalance() const;
    vector<Transaction*> getTransactionHistory() const;
    
    // 静态方法
    static void setInterestRate(double rate);
    static double getInterestRate();
};

class Transaction {
private:
    string transactionId;
    string type;  // "deposit", "withdraw", "transfer"
    double amount;
    string timestamp;
    BankAccount* sourceAccount;
    BankAccount* targetAccount;  // 仅用于转账

public:
    Transaction(string type, double amount, BankAccount* source, BankAccount* target = nullptr);
    
    // 获取交易信息
    string getTransactionId() const;
    string getType() const;
    double getAmount() const;
    string getTimestamp() const;
    BankAccount* getSourceAccount() const;
    BankAccount* getTargetAccount() const;
};

运行此系统时，可以创建账户并执行交易：

int main() {
    // 创建两个银行账户
    BankAccount account1("1001", "John Doe", 1000);
    BankAccount account2("1002", "Jane Smith", 500);
    
    // 设置利率
    BankAccount::setInterestRate(0.05);
    
    // 执行各种操作
    account1.deposit(200);               // 存款
    account1.withdraw(50);               // 取款
    account1.transfer(account2, 300);    // 转账
    
    // 显示账户信息
    cout << "Account: " << account1.getAccountNumber() << endl;
    cout << "Owner: " << account1.getOwnerName() << endl;
    cout << "Balance: $" << account1.getBalance() << endl;
    
    cout << "\nAccount: " << account2.getAccountNumber() << endl;
    cout << "Owner: " << account2.getOwnerName() << endl;
    cout << "Balance: $" << account2.getBalance() << endl;
    
    return 0;
}

输出：

Account: 1001
Owner: John Doe
Balance: $850

Account: 1002
Owner: Jane Smith
Balance: $800

类声明的最佳实践​

  1. 封装原则：将数据成员声明为私有，通过公有方法访问
  2. 职责单一：每个类应该只有一个明确的责任
  3. 接口与实现分离：在头文件中声明类，在源文件中实现成员函数
  4. 命名规范：使用清晰、描述性的命名，通常类名首字母大写
  5. 注释：在类声明中加入文档注释，说明类的用途和成员的功能

总结​

类声明是C++面向对象编程的基石，它定义了对象的结构和行为。通过正确声明类，我们可以创建具有特定特性和功能的对象，实现数据封装、代码复用等面向对象的核心理念。

类声明主要包括：

  • 访问修饰符（public、private、protected）
  • 数据成员（表示类的属性）
  • 成员函数（表示类的行为）
  • 特殊成员函数（构造函数、析构函数）
  • 静态成员和常量成员

掌握类声明是学习C++面向对象编程的第一步，为后续学习类的实现、继承、多态等高级概念奠定基础。

练习​

  1. 创建一个Car类，包含品牌、型号、年份等属性，以及启动、停止等方法。
  2. 设计一个Library类和Book类，使它们能够相互引用。
  3. 创建一个Counter类，包含静态成员来记录创建了多少个计数器对象。
  4. 设计一个ShoppingCart类，可以添加、删除和计算商品的总价。
  5. 重新设计上面的银行账户系统，添加利息计算和月度报表功能。

进一步学习资源​

  • C++ Primer（第5版）
  • Effective C++：改善程序与设计的55个具体做法
  • C++标准库：自学教程与参考手册
  • cppreference.com上关于类的文档

通过系统学习和反复实践，你将能够熟练运用C++类声明，为面向对象编程打下坚实基础。