C++ 类声明
引言
在C++中，类是面向对象编程的基本构建块。它是数据和函数的集合，代表现实世界中的实体。类声明是定义这些实体特性和行为的第一步，是学习C++面向对象编程的基础。
通过本文，你将学习：
- 类声明的基本语法
- 访问修饰符的使用
- 类成员（数据成员和成员函数）的声明
- 类声明与定义的区别
- 实际应用中的类声明案例
什么是类声明？
类声明是告诉编译器一个特定类型的类存在，它包含哪些数据和函数，以及它们的访问权限。类声明为程序设计提供了蓝图，就像建筑师的设计图纸一样。
基本语法
C++中类声明的基本语法如下：
cpp
class 类名 {
访问修饰符:
数据成员;
成员函数;
};
其中：
class是关键字类名遵循C++标识符命名规则，通常首字母大写访问修饰符控制对类成员的访问权限数据成员是类的属性（变量）成员函数是类的方法（函数）
访问修饰符
C++提供了三种访问修饰符：
- public: 可以被任何函数访问
- private: 只能被类的成员函数访问
- protected: 可以被类的成员函数和派生类访问
提示
如果不指定访问修饰符，类中的成员默认为private。
简单的类声明示例
下面是一个简单的Student类声明：
cpp
class Student {
public:
// 公有成员函数
void setName(string n);
string getName();
void setAge(int a);
int getAge();
private:
// 私有数据成员
string name;
int age;
};
声明数据成员
数据成员是类的变量，用于存储类的状态信息。
cpp
class Rectangle {
private:
double length; // 长度
double width; // 宽度
public:
// 成员函数声明将在后面介绍
};
数据成员的特点
- 封装性：通常声明为私有，通过公有方法访问
- 持久性：对象存在期间，数据成员一直存在
- 类型多样性：可以是基本类型、指针、引用或其他类的对象
声明成员函数
成员函数是类的函数，用于操作类的数据成员，实现类的行为。
cpp
class Circle {
private:
double radius;
public:
// 构造函数
Circle();
Circle(double r);
// 普通成员函数
double getArea();
double getPerimeter();
// 设置和获取属性的函数
void setRadius(double r);
double getRadius();
};
成员函数的声明与定义分离
C++允许将类的声明和成员函数的定义分开：
cpp
// 类声明部分
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;
}
内联成员函数
如果在类声明中直接定义成员函数，则该函数自动成为内联函数：
cpp
class Counter {
private:
unsigned int count;
public:
// 内联成员函数
Counter() { count = 0; }
void increment() { count++; }
unsigned int getCount() { return count; }
};
构造函数和析构函数的声明
构造函数和析构函数是特殊的成员函数，分别在对象创建和销毁时自动调用：
cpp
class Person {
private:
string* name;
int age;
public:
// 构造函数
Person(); // 默认构造函数
Person(string n, int a); // 带参数构造函数
Person(const Person& p); // 复制构造函数
// 析构函数
~Person();
// 其他成员函数
void display();
};
类声明中的静态成员
静态成员属于类而非对象，所有对象共享一个静态成员副本：
cpp
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(); // 静态成员函数
};
备注
静态数据成员通常需要在类外进行定义和初始化。
类声明中的常量成员函数
常量成员函数承诺不会修改对象的状态：
cpp
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);
};
类的前向声明
当两个类相互引用时，可以使用前向声明：
cpp
// 前向声明
class B;
class A {
private:
B* b;
public:
void setB(B* ptr);
};
class B {
private:
A* a;
public:
void setA(A* ptr);
};
实际案例：银行账户系统
下面是一个银行账户系统的类声明示例，展示了类声明在实际应用中的使用：
cpp
// 前向声明
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;
};
运行此系统时，可以创建账户并执行交易：
cpp
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
类声明的最佳实践
- 封装原则：将数据成员声明为私有，通过公有方法访问
- 职责单一：每个类应该只有一个明确的责任
- 接口与实现分离：在头文件中声明类，在源文件中实现成员函数
- 命名规范：使用清晰、描述性的命名，通常类名首字母大写
- 注释：在类声明中加入文档注释，说明类的用途和成员的功能
总结
类声明是C++面向对象编程的基石，它定义了对象的结构和行为。通过正确声明类，我们可以创建具有特定特性和功能的对象，实现数据封装、代码复用等面向对象的核心理念。
类声明主要包括：
- 访问修饰符（public、private、protected）
- 数据成员（表示类的属性）
- 成员函数（表示类的行为）
- 特殊成员函数（构造函数、析构函数）
- 静态成员和常量成员
掌握类声明是学习C++面向对象编程的第一步，为后续学习类的实现、继承、多态等高级概念奠定基础。
练习
- 创建一个
Car类，包含品牌、型号、年份等属性，以及启动、停止等方法。 - 设计一个
Library类和Book类，使它们能够相互引用。 - 创建一个
Counter类，包含静态成员来记录创建了多少个计数器对象。 - 设计一个
ShoppingCart类，可以添加、删除和计算商品的总价。 - 重新设计上面的银行账户系统，添加利息计算和月度报表功能。
进一步学习资源
- C++ Primer（第5版）
- Effective C++：改善程序与设计的55个具体做法
- C++标准库：自学教程与参考手册
- cppreference.com上关于类的文档
通过系统学习和反复实践，你将能够熟练运用C++类声明，为面向对象编程打下坚实基础。