若基类的虚函数在派生类内没有被重写，是否还可调用，请举例

是可以调用的。下面是一个示例代码：

#include <iostream>

using namespace std;

class Base {
public:
    virtual void func() {
        cout << "Base::func()" << endl;
    }
};

class Derived : public Base {
public:
    // 没有重写 Base::func()
};

int main() {
    Base* ptr = new Derived();
    ptr->func(); // 调用的是 Base::func()
    delete ptr;
    return 0;
}

在这个示例中，`Base` 类有一个虚函数 `func()`，`Derived` 类从 `Base` 继承，但没有重写 `func()`。在 `main()` 函数中，我们创建了一个 `Derived` 类型的对象，并将其地址赋给一个 `Base` 类型的指针 `ptr`，然后调用 `ptr->func()`。由于 `func()` 是虚函数，因此会根据指针指向的对象类型来决定调用哪个版本的函数。在这个例子中，`ptr` 指向的对象是 `Derived` 类型的，但由于 `Derived` 类没有重写 `func()`，因此会调用 `Base` 类的版本，输出 `Base::func()`。

相关问题

举例说明：含有继承关系的类中虚函数的调用

假设有一个基类Animal和两个派生类Dog和Cat，Animal类中有一个虚函数speak()，Dog和Cat类分别重写了speak()函数。

在程序中，可以用基类指针指向派生类对象，然后通过这个指针调用虚函数speak()。这样可以实现多态性，即程序会根据实际指向的对象类型来调用相应的函数。

例如：

class Animal {
public:
    virtual void speak() {
        cout << "I am an animal." << endl;
    }
};

class Dog : public Animal {
public:
    virtual void speak() {
        cout << "I am a dog." << endl;
    }
};

class Cat : public Animal {
public:
    virtual void speak() {
        cout << "I am a cat." << endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();
    animal1->speak();  // 输出"I am a dog."
    animal2->speak();  // 输出"I am a cat."
    return 0;
}

在这个例子中，animal1和animal2是Animal类的指针，但分别指向了Dog类和Cat类的对象。通过调用它们的虚函数speak()，程序会根据实际指向的对象类型来调用相应的函数，输出"I am a dog."和"I am a cat."。这就是利用虚函数实现多态性的例子。

派生类的对象的地址可以赋给指向基类的指针举例

好的，我来举个例子。假设有一个基类 Animal，有一个成员函数 eat()，派生类 Dog 继承自 Animal，重写了它的 eat() 函数并添加了一个新的成员函数 bark()。现在我们可以创建一个 Dog 对象，然后将其地址赋给一个指向 Animal 的指针，这样就可以通过该指针来访问 Dog 对象的成员了。代码如下：

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void eat() {
        cout << "Animal is eating." << endl;
    }
};

class Dog : public Animal {
public:
    void eat() {
        cout << "Dog is eating." << endl;
    }
    void bark() {
        cout << "Dog is barking." << endl;
    }
};

int main() {
    Dog myDog;
    Animal* pAnimal = &myDog;
    pAnimal->eat(); // 调用的是 Dog 类中的 eat() 函数
    // pAnimal->bark(); // 错误，Animal 类没有 bark() 函数
    return 0;
}

在这个例子中，我们定义了 Animal 和 Dog 两个类，Dog 继承自 Animal，重写了 eat() 函数并添加了一个新的成员函数 bark()。在 main 函数中，我们创建了一个 Dog 对象 myDog，并将其地址赋给一个指向 Animal 的指针 pAnimal。然后我们通过该指针调用了 eat() 函数，由于 eat() 在 Dog 类中被重写了，因此调用的是 Dog 类中的 eat() 函数。但是由于 Animal 类中没有 bark() 函数，因此无法通过 pAnimal 来访问 Dog 对象中的 bark() 函数。