C++ 设计模式面试题解析与代码实现
在设计模式领域，C++ 作为一种强大的编程语言，被广泛应用于系统级编程和性能敏感的应用。掌握设计模式对于面试来说至关重要，因为它不仅体现了面试者的编程能力，还展示了其对软件工程原则的理解。本文将围绕 C++ 设计模式，解析一些常见的面试题，并提供相应的代码实现。
1. 单例模式（Singleton）
单例模式确保一个类只有一个实例，并提供一个全局访问点。
面试题
请实现一个单例类，要求该类在全局范围内只有一个实例。
代码实现
cpp
include
class Singleton {
private:
static Singleton instance;
Singleton() {}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
public:
static Singleton getInstance() {
if (instance == nullptr) {
instance = new Singleton();
}
return instance;
}
void doSomething() {
std::cout << "Doing something..." << std::endl;
}
static void releaseInstance() {
if (instance != nullptr) {
delete instance;
instance = nullptr;
}
}
};
Singleton Singleton::instance = nullptr;
int main() {
Singleton s1 = Singleton::getInstance();
Singleton s2 = Singleton::getInstance();
std::cout << "s1 == s2: " << (s1 == s2) <doSomething();
Singleton::releaseInstance();
return 0;
}
2. 工厂模式（Factory Method）
工厂模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。
面试题
请实现一个工厂模式，创建不同类型的汽车。
代码实现
cpp
include
include
class Car {
public:
virtual void drive() = 0;
virtual ~Car() {}
};
class Sedan : public Car {
public:
void drive() override {
std::cout << "Driving a Sedan..." << std::endl;
}
};
class SUV : public Car {
public:
void drive() override {
std::cout << "Driving an SUV..." << std::endl;
}
};
class CarFactory {
public:
virtual std::unique_ptr createCar() = 0;
virtual ~CarFactory() {}
};
class SedanFactory : public CarFactory {
public:
std::unique_ptr createCar() override {
return std::make_unique();
}
};
class SUVFactory : public CarFactory {
public:
std::unique_ptr createCar() override {
return std::make_unique();
}
};
int main() {
CarFactory sedanFactory = new SedanFactory();
CarFactory suvFactory = new SUVFactory();
std::unique_ptr sedan = sedanFactory->createCar();
std::unique_ptr suv = suvFactory->createCar();
sedan->drive();
suv->drive();
delete sedanFactory;
delete suvFactory;
return 0;
}
3. 观察者模式（Observer）
观察者模式定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。
面试题
请实现一个观察者模式，当数据更新时，所有观察者都能得到通知。
代码实现
cpp
include
include
include
class Observer {
public:
virtual void update(int data) = 0;
virtual ~Observer() {}
};
class ConcreteObserver : public Observer {
public:
void update(int data) override {
std::cout << "Observer received data: " << data << std::endl;
}
};
class Subject {
private:
std::vector<#std::shared_ptr> observers;
int data;
public:
void attach(std::shared_ptr observer) {
observers.push_back(observer);
}
void detach(std::shared_ptr observer) {
observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
}
void notify() {
for (auto& observer : observers) {
observer->update(data);
}
}
void setData(int data) {
this->data = data;
notify();
}
};
int main() {
Subject subject;
std::shared_ptr observer1 = std::make_shared();
std::shared_ptr observer2 = std::make_shared();
subject.attach(observer1);
subject.attach(observer2);
subject.setData(10);
subject.setData(20);
subject.detach(observer1);
subject.setData(30);
return 0;
}
4. 策略模式（Strategy）
策略模式定义一系列算法，把它们一个个封装起来，并使它们可以互相替换。
面试题
请实现一个策略模式，根据不同的排序算法对数组进行排序。
代码实现
cpp
include
include
include
class SortStrategy {
public:
virtual void sort(std::vector& data) = 0;
virtual ~SortStrategy() {}
};
class BubbleSort : public SortStrategy {
public:
void sort(std::vector& data) override {
std::sort(data.begin(), data.end());
}
};
class QuickSort : public SortStrategy {
public:
void sort(std::vector& data) override {
std::sort(data.begin(), data.end());
}
};
class Context {
private:
std::shared_ptr strategy;
public:
void setStrategy(std::shared_ptr strategy) {
this->strategy = strategy;
}
void sort(std::vector& data) {
strategy->sort(data);
}
};
int main() {
Context context;
std::vector data = {5, 2, 9, 1, 5, 6};
context.setStrategy(std::make_shared());
context.sort(data);
for (int i : data) {
std::cout << i << " ";
}
std::cout << std::endl;
context.setStrategy(std::make_shared());
context.sort(data);
for (int i : data) {
std::cout << i << " ";
}
std::cout << std::endl;
return 0;
}
总结
本文通过解析和代码实现，展示了 C++ 中几种常见的设计模式。掌握这些设计模式对于面试和实际项目开发都具有重要意义。在实际应用中，应根据具体场景选择合适的设计模式，以提高代码的可维护性和可扩展性。
Comments NOTHING