C++中如何公用继承一个类

在C++中，可以使用关键字"public"来表示公用继承一个类。公用继承意味着派生类将获得基类中的所有公有成员和方法，而私有成员和方法则无法直接访问。

下面是一个示例代码，展示了如何使用公用继承：

class Base {
public:
    int publicVar;

    void publicMethod() {
        // 公有方法的实现
    }
};

class Derived : public Base {
    // 派生类的成员和方法
};

在上面的示例中，`Derived` 类使用 `public` 关键字继承了 `Base` 类。这意味着 `Derived` 类将继承 `Base` 类中的公有成员变量 `publicVar` 和公有方法 `publicMethod()`。可以在派生类中直接访问这些继承的成员和方法。

需要注意的是，公用继承还包括了基类的保护成员，但是私有成员无法直接访问。如果希望派生类能够访问基类的私有成员，可以使用友元关系或者提供公有的访问函数来实现。

相关问题

用c++验证公用继承下基类的公用成员在派生类依然为公用成员

可以使用以下代码来验证公用继承下基类的公用成员在派生类依然为公用成员：

#include<iostream>
using namespace std;

class Base{
public:
    int publicMember;
};

class Derived:public Base{
public:
    void print(){
        cout<<"publicMember in Derived class: "<<publicMember<<endl;
    }
};

int main(){
    Derived d;
    d.publicMember = 100;
    d.print();
    return 0;
}

在上面的代码中，我们定义了一个基类 `Base`，其中有一个公用成员 `publicMember`。然后我们定义了一个派生类 `Derived`，并使用公用继承将其继承自 `Base`。在 `Derived` 类中，我们定义了一个成员函数 `print`，用于打印公用成员 `publicMember` 的值。

在 `main` 函数中，我们创建了一个 `Derived` 类的对象 `d`，并将其公用成员 `publicMember` 的值设置为 100。然后调用 `d` 对象的 `print` 函数，打印出公用成员 `publicMember` 的值。

运行代码，可以看到输出结果为：

publicMember in Derived class: 100

说明在公用继承下，基类的公用成员在派生类中依然为公用成员。

用C++代码写一个模板方法模式

模板方法模式是一种行为设计模式，它定义了一个算法的骨架，将一些步骤延迟到子类中实现。该模式主要由一个抽象类和提供实现的具体子类组成。C语言可以通过函数指针实现模板方法模式，具体实现如下：

#include <stdio.h>

/* 抽象基类 */
struct AbstractClass{
    /* 模板方法，该方法定义了算法的骨架 */
    void (*templateMethod)(struct AbstractClass*);
};

/* 具体实现类1 */
struct ConcreteClass1{
    struct AbstractClass super; /* 具体实现类1继承了抽象基类 */

    /* 子类实现的具体方法 */
    void (*primitiveOperation1)(void){
        printf("ConcreteClass1 implements primitiveOperation1\n");
    }

    /* 子类实现的具体方法 */
    void (*primitiveOperation2)(void){
        printf("ConcreteClass1 implements primitiveOperation2\n");
    }
};

/* 具体实现类2 */
struct ConcreteClass2{
    struct AbstractClass super; /* 具体实现类2继承了抽象基类 */

    /* 子类实现的具体方法 */
    void (*primitiveOperation1)(void){
        printf("ConcreteClass2 implements primitiveOperation1\n");
    }

    /* 子类实现的具体方法 */
    void (*primitiveOperation2)(void){
        printf("ConcreteClass2 implements primitiveOperation2\n");
    }
};

/* 具体实现类1实现的模板方法 */
void ConcreteClass1_templateMethod(struct AbstractClass* this){
    struct ConcreteClass1* concrete = (struct ConcreteClass1*)this;
    concrete->primitiveOperation1();
    concrete->primitiveOperation2();
}

/* 具体实现类2实现的模板方法 */
void ConcreteClass2_templateMethod(struct AbstractClass* this){
    struct ConcreteClass2* concrete = (struct ConcreteClass2*)this;
    concrete->primitiveOperation2();
    concrete->primitiveOperation1();
}

int main(int argc, char* argv[]){
    /* 初始化具体实现类1对象 */
    struct ConcreteClass1 concrete1 = {
        .super = {.templateMethod = &ConcreteClass1_templateMethod},
        .primitiveOperation1 = &ConcreteClass1_primitiveOperation1,
        .primitiveOperation2 = &ConcreteClass1_primitiveOperation2
    };
    /* 初始化具体实现类2对象 */
    struct ConcreteClass2 concrete2 = {
        .super = {.templateMethod = &ConcreteClass2_templateMethod},
        .primitiveOperation1 = &ConcreteClass2_primitiveOperation1,
        .primitiveOperation2 = &ConcreteClass2_primitiveOperation2
    };

    /* 调用具体实现类1的模板方法 */
    concrete1.super.templateMethod(&concrete1.super);
    /* 调用具体实现类2的模板方法 */
    concrete2.super.templateMethod(&concrete2.super);

    return 0;
}

以上就是使用C语言实现模板方法模式的代码。每个具体实现类继承了抽象基类，并实现了自己的子类具体方法。模板方法以函数指针方式存在于抽象基类中，并被具体实现类所调用。通过模板方法模式，我们可以公用代码骨架，实现代码的复用性和扩展性。