C继承与组合设计继承和组合是面向对象设计中两种重要的代码复用机制。继承表示是一个关系而组合表示有一个关系。理解何时使用继承、何时使用组合是设计良好系统的关键。继承允许派生类继承基类的属性和方法实现代码复用和多态。#include#include#include#includeclass Vehicle {protected:std::string brand_;int year_;public:Vehicle(const std::string brand, int year): brand_(brand), year_(year) {}virtual ~Vehicle() default;virtual void start() const {std::cout brand_ vehicle starting\n;}virtual void stop() const {std::cout brand_ vehicle stopping\n;}std::string brand() const { return brand_; }int year() const { return year_; }};class Car : public Vehicle {int doors_;public:Car(const std::string brand, int year, int doors): Vehicle(brand, year), doors_(doors) {}void start() const override {std::cout brand_ car with doors_ doors starting\n;}int doors() const { return doors_; }};class Motorcycle : public Vehicle {bool has_sidecar_;public:Motorcycle(const std::string brand, int year, bool sidecar): Vehicle(brand, year), has_sidecar_(sidecar) {}void start() const override {std::cout brand_ motorcycle starting;if (has_sidecar_) std::cout (with sidecar);std::cout \n;}};void inheritance_example() {std::vector vehicles;vehicles.push_back(std::make_unique(Toyota, 2020, 4));vehicles.push_back(std::make_unique(Harley, 2019, false));for (const auto v : vehicles) {v-start();}}组合通过包含其他对象来实现功能复用提供了更大的灵活性。class Engine {int horsepower_;public:explicit Engine(int hp) : horsepower_(hp) {}void start() const {std::cout Engine ( horsepower_ hp) starting\n;}void stop() const {std::cout Engine stopping\n;}int horsepower() const { return horsepower_; }};class Transmission {std::string type_;public:explicit Transmission(const std::string type) : type_(type) {}void shift_gear(int gear) const {std::cout type_ transmission shifting to gear gear \n;}};class ComposedCar {std::string brand_;Engine engine_;Transmission transmission_;public:ComposedCar(const std::string brand, int hp, const std::string trans_type): brand_(brand), engine_(hp), transmission_(trans_type) {}void start() const {std::cout brand_ car starting\n;engine_.start();}void drive() const {transmission_.shift_gear(1);transmission_.shift_gear(2);}void stop() const {engine_.stop();}};void composition_example() {ComposedCar car(Honda, 200, Automatic);car.start();car.drive();car.stop();}多重继承允许一个类继承多个基类但需要小心处理菱形继承问题。class Printable {public:virtual ~Printable() default;virtual void print() const 0;};class Serializable {public:virtual ~Serializable() default;virtual std::string serialize() const 0;};class Document : public Printable, public Serializable {std::string content_;public:explicit Document(const std::string content) : content_(content) {}void print() const override {std::cout Printing: content_ \n;}std::string serialize() const override {return DOC: content_;}};void multiple_inheritance_example() {Document doc(Important document);doc.print();std::cout Serialized: doc.serialize() \n;}接口继承定义纯虚函数强制派生类实现特定接口。class ILogger {public:virtual ~ILogger() default;virtual void log(const std::string message) 0;};class ConsoleLogger : public ILogger {public:void log(const std::string message) override {std::cout [Console] message \n;}};class FileLogger : public ILogger {std::string filename_;public:explicit FileLogger(const std::string filename) : filename_(filename) {}void log(const std::string message) override {std::cout [File: filename_ ] message \n;}};class Application {ILogger* logger_;public:explicit Application(ILogger* logger) : logger_(logger) {}void run() {logger_-log(Application started);logger_-log(Processing data);logger_-log(Application finished);}};void interface_inheritance_example() {ConsoleLogger console;FileLogger file(app.log);Application app1(console);app1.run();Application app2(file);app2.run();}组合优于继承是一个重要的设计原则提供了更好的灵活性和可测试性。class Renderer {public:virtual ~Renderer() default;virtual void render(const std::string content) const 0;};class HTMLRenderer : public Renderer {public:void render(const std::string content) const override {std::cout content \n;}};class MarkdownRenderer : public Renderer {public:void render(const std::string content) const override {std::cout # content \n;}};class Page {std::string title_;std::string content_;std::unique_ptr renderer_;public:Page(const std::string title, const std::string content,std::unique_ptr renderer): title_(title), content_(content), renderer_(std::move(renderer)) {}void display() const {std::cout Title: title_ \n;renderer_-render(content_);}void set_renderer(std::unique_ptr renderer) {renderer_ std::move(renderer);}};void composition_over_inheritance() {Page page(Welcome, Hello World, std::make_unique());page.display();page.set_renderer(std::make_unique());page.display();}私有继承实现用...实现的关系不是是一个关系。class Timer {protected:int seconds_;public:explicit Timer(int seconds) : seconds_(seconds) {}void tick() {if (seconds_ 0) {--seconds_;std::cout Time remaining: seconds_ s\n;}}bool expired() const {return seconds_ 0;}};class Alarm : private Timer {public:explicit Alarm(int seconds) : Timer(seconds) {}void check() {tick();if (expired()) {std::cout ALARM! Times up!\n;}}};void private_inheritance_example() {Alarm alarm(3);alarm.check();alarm.check();alarm.check();alarm.check();}继承和组合的选择取决于具体场景理解两者的优缺点是做出正确设计决策的关键。