友元函数(Friend Functions)
友元函数是一种特殊的函数,它被允许访问类的私有成员。这意味着即使成员是私有的,友元函数也能够直接访问它们,而不需要通过公有接口。这提供了更多的灵活性,允许外部函数与类密切合作。
示例-演示如何声明和使用友元函数:
#include
class MyClass {
private:
int secretData;
public:
MyClass() : secretData(0) {}
friend void FriendFunction(MyClass& obj); // 友元函数的声明
};
// 友元函数的定义
void FriendFunction(MyClass& obj) {
obj.secretData = 42; // 可以访问私有成员
}
int main() {
MyClass myObj;
FriendFunction(myObj); // 调用友元函数
std::cout << myObj.secretData << std::endl; // 输出 42
return 0;
}
示例中,FriendFunction
被声明为 MyClass
的友元函数,可以直接访问 secretData
私有成员。
友元类(Friend Classes)
友元类与友元函数类似,但它允许整个类成为另一个类的友元,而不仅仅是一个函数。这意味着友元类的所有成员都可以访问其他类的私有成员。
class MyClass {
private:
int secretData;
public:
MyClass() : secretData(0) {}
friend class FriendClass; // 友元类的声明
};
class FriendClass {
public:
void AccessPrivateData(MyClass& obj) {
obj.secretData = 42; // 可以访问私有成员
}
};
int main() {
MyClass myObj;
FriendClass friendObj;
friendObj.AccessPrivateData(myObj); // 通过友元类访问私有成员
std::cout << myObj.secretData << std::endl; // 输出 42
return 0;
}
FriendClass
被声明为 MyClass
的友元类,因此它的成员函数可以访问 secretData
私有成员。
拷贝构造函数是C++中的一个特殊构造函数,用于创建一个对象的副本。当对象按值传递给函数、作为函数的返回值返回或者在初始化过程中需要复制时,拷贝构造函数会被自动调用。它用于确保对象的复制是正确的,包括成员变量的深拷贝。
示例-演示了如何定义和使用拷贝构造函数:
#include
#include
class MyString {
private:
char* str;
public:
// 构造函数,用于创建字符串对象
MyString(const char* s) {
str = new char[strlen(s) + 1];
strcpy(str, s);
}
// 拷贝构造函数,用于创建对象的副本
MyString(const MyString& other) {
str = new char[strlen(other.str) + 1];
strcpy(str, other.str);
}
// 析构函数,用于释放内存
~MyString() {
delete[] str;
}
// 显示字符串内容
void display() {
std::cout << str << std::endl;
}
};
int main() {
MyString original("Hello, World!");
MyString copy = original; // 使用拷贝构造函数创建副本
original.display(); // 输出 "Hello, World!"
copy.display(); // 输出 "Hello, World!"
return 0;
}
在示例中,首先定义了一个 MyString
类,它包含一个字符数组 str
用于存储字符串。然后,定义一个拷贝构造函数,通过分配新内存并复制原始对象的内容来创建副本。最后,在 main
函数中,创建了一个 original
对象,并使用拷贝构造函数创建了 copy
对象。这两个对象分别存储相同的字符串内容,但它们在内存中有不同的副本。
运算符重载是C++中一种强大的特性,它允许为自定义类创建特定的运算符行为。通过运算符重载,可以让对象像内置类型一样执行加法、减法、乘法等操作,使代码更直观和易读。
示例-演示如何重载加法运算符:
#include
class Complex {
private:
double real;
double imag;
public:
Complex(double r, double i) : real(r), imag(i) {}
// 运算符重载:重载+运算符,实现复数相加
Complex operator+(const Complex& other) const {
return Complex(real + other.real, imag + other.imag);
}
// 显示复数
void display() const {
std::cout << real << " + " << imag << "i" << std::endl;
}
};
int main() {
Complex num1(3.0, 2.0);
Complex num2(1.5, 4.5);
Complex result = num1 + num2; // 使用重载的+运算符
num1.display(); // 输出 "3 + 2i"
num2.display(); // 输出 "1.5 + 4.5i"
result.display(); // 输出 "4.5 + 6.5i"
return 0;
}
在示例中,定义一个 Complex
类表示复数。然后,重载加法运算符 +
,使得两个 Complex
对象可以像内置数值类型一样相加。通过运算符重载,让复数对象的操作更自然和直观。
在C++中,静态成员和静态函数是属于整个类而不是类的实例的。它们被称为类级别的成员,与类的每个实例无关,而是与类本身关联。
静态成员是在类级别共享的数据成员。它们对于所有类的实例都是相同的。要声明静态成员,可以使用 static
关键字。
#include
class MyClass {
public:
static int count; // 静态成员变量
MyClass() {
count++; // 每次创建实例时增加计数
}
static void showCount() {
std::cout << "Total instances: " << count << std::endl;
}
};
int MyClass::count = 0; // 初始化静态成员变量
int main() {
MyClass obj1;
MyClass obj2;
MyClass obj3;
MyClass::showCount(); // 调用静态函数显示计数
return 0;
}
我们创建一个名为 MyClass
的类,包含一个静态整数 count
用于跟踪创建的实例数。创建 MyClass
的实例时,静态成员变量 count
都会增加。定义一个静态函数 showCount
来显示实例的总数。
静态函数是在类级别共享的成员函数。它们不需要访问类的实例数据,因此可以在没有实例的情况下调用。静态函数使用与类相关的方式调用,而不是使用实例。
在C++中,类的继承和多态性是面向对象编程的核心概念之一。它们允许构建更强大、更灵活的对象模型。
类的继承允许创建一个新的类(称为派生类),它可以继承另一个类(称为基类)的属性和行为。可以在现有类的基础上创建新类,而不必从头开始编写代码。派生类可以添加额外的成员变量和成员函数,也可以覆盖基类的成员函数以改变其行为。
#include
// 基类
class Shape {
public:
virtual void draw() {
std::cout << "绘制形状" << std::endl;
}
};
// 派生类
class Circle : public Shape {
public:
void draw() override {
std::cout << "绘制圆形" << std::endl;
}
};
int main() {
Shape shape;
Circle circle;
shape.draw(); // 输出:绘制形状
circle.draw(); // 输出:绘制圆形
return 0;
}
基类 Shape
和一个派生类 Circle
。派生类继承了基类的 draw
函数,并覆盖了它以提供不同的行为。在 main
函数中,我们创建了基类和派生类的对象,然后调用它们的 draw
函数,演示了多态性的概念。
多态性是一种能够在运行时选择正确函数版本的机制。在上面的示例中,Shape
类的 draw
函数是虚函数,而 Circle
类中的 draw
函数使用了 override
关键字来表示它是一个覆盖了基类函数的虚函数。这允许我们在基类指针或引用的上下文中调用派生类的函数,而选择的是正确的版本。
1. 创建一个类 Fraction
表示分数,包括分子和分母。编写运算符重载函数,实现分数的加法和减法运算:
#include
class Fraction {
private:
int numerator;
int denominator;
public:
Fraction(int num, int den) : numerator(num), denominator(den) {
// Ensure denominator is not zero
if (denominator == 0) {
std::cerr << "Error: Denominator cannot be zero." << std::endl;
exit(1);
}
}
// Overload the + operator to add fractions
Fraction operator+(const Fraction& other) const {
int newNumerator = numerator * other.denominator + other.numerator * denominator;
int newDenominator = denominator * other.denominator;
return Fraction(newNumerator, newDenominator);
}
// Overload the - operator to subtract fractions
Fraction operator-(const Fraction& other) const {
int newNumerator = numerator * other.denominator - other.numerator * denominator;
int newDenominator = denominator * other.denominator;
return Fraction(newNumerator, newDenominator);
}
void display() const {
std::cout << numerator << "/" << denominator << std::endl;
}
};
int main() {
Fraction frac1(1, 2);
Fraction frac2(1, 3);
Fraction sum = frac1 + frac2;
Fraction diff = frac1 - frac2;
std::cout << "Fraction 1: ";
frac1.display();
std::cout << "Fraction 2: ";
frac2.display();
std::cout << "Sum: ";
sum.display();
std::cout << "Difference: ";
diff.display();
return 0;
}
解答说明:
Fraction
的类,表示分数,包括分子和分母属性。+
和 -
运算符,实现了分数的加法和减法。main()
函数中,创建两个分数对象 frac1
和 frac2
,然后对它们进行加法和减法运算。2. 创建一个基类 Vehicle
表示交通工具,包括名称和速度属性。创建两个派生类 Car
和 Bike
,它们继承了基类并添加了特定的属性:
#include
#include
class Vehicle {
protected:
std::string name;
double speed;
public:
Vehicle(const std::string& n, double s) : name(n), speed(s) {}
void display() const {
std::cout << "Name: " << name << ", Speed: " << speed << " km/h" << std::endl;
}
};
class Car : public Vehicle {
private:
int numWheels;
public:
Car(const std::string& n, double s, int wheels) : Vehicle(n, s), numWheels(wheels) {}
void display() const {
std::cout << "Car - ";
Vehicle::display();
std::cout << "Wheels: " << numWheels << std::endl;
}
};
class Bike : public Vehicle {
private:
bool hasBasket;
public:
Bike(const std::string& n, double s, bool basket) : Vehicle(n, s), hasBasket(basket) {}
void display() const {
std::cout << "Bike - ";
Vehicle::display();
std::cout << "Basket: " << (hasBasket ? "Yes" : "No") << std::endl;
}
};
int main() {
Car car("Sedan", 120.0, 4);
Bike bike("Mountain Bike", 25.0, true);
car.display();
bike.display();
return 0;
}
解答说明:
Vehicle
,包括名称和速度属性。Car
和 Bike
,它们继承了基类 Vehicle
并添加了特定的属性。main()
函数中,创建了一个 Car
对象和一个 Bike
对象,分别调用它们的 display()
方法以显示车辆信息,包括名称、速度等。3. 使用多态性存储和调用不同类型的动物对象:
#include
#include
class Animal {
public:
virtual void speak() const {
std::cout << "Animal speaks." << std::endl;
}
};
class Dog : public Animal {
public:
void speak() const override {
std::cout << "Dog barks." << std::endl;
}
};
class Cat : public Animal {
public:
void speak() const override {
std::cout << "Cat meows." << std::endl;
}
};
int main() {
std::vector<Animal*> animals;
animals.push_back(new Dog());
animals.push_back(new Cat());
for (const auto& animal : animals) {
animal->speak();
delete animal; // Don't forget to free memory
}
return 0;
}
解答说明:
Animal
,创建两个派生类 Dog
和 Cat
。speak()
以实现不同类型的动物的声音。speak()
,实际执行的是派生类的版本。4. 银行账户类 BankAccount
和友元函数 transfer
:
#include
class BankAccount; // Forward declaration
class BankAccount {
private:
std::string accountNumber;
double balance;
public:
BankAccount(const std::string& accNum, double initBalance) : accountNumber(accNum), balance(initBalance) {}
void displayBalance() const {
std::cout << "Account: " << accountNumber << ", Balance: " << balance << " USD" << std::endl;
}
friend void transfer(BankAccount& from, BankAccount& to, double amount);
};
void transfer(BankAccount& from, BankAccount& to, double amount) {
if (from.balance >= amount) {
from.balance -= amount;
to.balance += amount;
std::cout << "Transfer successful." << std::endl;
} else {
std::cout << "Insufficient balance for transfer." << std::endl;
}
}
int main() {
BankAccount acc1("12345", 1000.0);
BankAccount acc2("67890", 500.0);
acc1.displayBalance();
acc2.displayBalance();
transfer(acc1, acc2, 300.0); // Transfer money from acc1 to acc2
acc1.displayBalance();
acc2.displayBalance();
return 0;
}
解答说明:
BankAccount
,包括账户号码和余额属性。transfer
实现了账户之间的资金转移。main()
中,创建两个账户,显示它们的余额,然后进行转账操作。5. 图形类 Shape
和派生类 Circle
和 Rectangle
,计算总面积:
#include
#include
class Shape {
protected:
std::string color;
public:
Shape(const std::string& c) : color(c) {}
virtual double getArea() const {
return 0.0; // Default area for a generic shape
}
};
class Circle : public Shape {
private:
double radius;
public:
Circle(const std::string& c, double r) : Shape(c), radius(r) {}
double getArea() const override {
return 3.14159 * radius * radius; // Area of a circle
}
};
class Rectangle : public Shape {
private:
double width;
double height;
public:
Rectangle(const std::string& c, double w, double h) : Shape(c), width(w), height(h) {}
double getArea() const override {
return width * height; // Area of a rectangle
}
};
int main() {
std::vector<Shape*> shapes;
shapes.push_back(new Circle("Red", 5.0));
shapes.push_back(new Rectangle("Blue", 4.0, 6.0));
double totalArea = 0.0;
for (const auto& shape : shapes) {
totalArea += shape->getArea();
delete shape; // Don't forget to free memory
}
std::cout << "Total Area: " << totalArea << std::endl;
return 0;
}
解答说明:
Shape
,创建两个派生类 Circle
和 Rectangle
,重写虚函数 getArea()
以返回不同形状的面积。