什么是基类构造函数?

Public class NewButton

Inherits Button

sub New (byval Newcolor as color )

meBackColor =Newcolor

end sub

end class

以上代码是类于系统按钮新建一个按钮类，并且添加了构造函数

public class form1

Dim buttom1 As NewButton

end

说明：上一段是一个新button类，里面的sub new 是构造函数

下一段是一个Form类，也就是窗体，基于NewButton定义了一个新按钮button1，就是说这个按钮的基类是NewButton

那上一段里的sub new函数 就是button1的基类构造函数。

派生的类C继承了A,B的构造函数，故可以不用再构造，当然也可以根据具体需要再构造一个自己想要的构造函数，比如：

C(char ch){y=ch;}

int&不是什么类型,是int &AccessAX(); 意思是引用AccessAX()。返回的是int 型。

基类虚析构，是为了在多态中，能正确调用到对应的析构函数。

例如：

class A{ public:virtual ~A();}

class B: public A{public:~B();}

具体实现略去，只看继承关系，那么当我有如下代码：

A p = new B();

delete p;

此时如果不是虚析构函数，则只会调用到A的析构函数，而不会调用B的析构函数，这样会产生一系列的问题。

只有虚析构函数，才能确保调用到正确的函数（B的析构）。

用于函数继承当中实现动态绑定。

比如你的基类有一个成员函数 void print(){cout<<"这是基类"<<endl;

而你派生了一个类出来，如果你用派生类对象调用print时，输出的也是"这是基类"而不是派生类中重新定义的"这是派生类"

如果virtual关键字决定是虚函数，那么将会动态绑定，程序会在运行时决定调用哪一个。

你可以去查查相关资料。

----------------------------------

本人也是学生，不是高手,大家共同学习，共同进步。回答可能不是完全正确，希望原谅。

构造函数重载的3个条件：具有相同的名字；参数个数不同；参数类型不同。

所以第2个构造函数不可能实现。

当然如果derived中新增的数据成员不为int型，则可以用以下方式设计构造函数

#include <iostream>

using namespace std;

class Basic

{

private:

int a;

public:

Basic()

{

a = 1;

}

Basic(int x)

{

a = x;

}

int getA()

{

return a;

}

};

class Derived : public Basic

{

private:

double b;

public:

Derived():Basic()

{

b = 1;

}

Derived(int x):Basic(x)

{

b = 1;

}

Derived(double y):Basic()

{

b = y;

}

Derived(int x, double y):Basic(x)

{

b = y;

}

double getB()

{

return b;

}

};

int main()

{

Derived d1;

Derived d2(2);

Derived d3(34);

Derived d4(5, 67);

cout << "a=" << d1getA() << " b=" << d1getB() << endl;

cout << "a=" << d2getA() << " b=" << d2getB() << endl;

cout << "a=" << d3getA() << " b=" << d3getB() << endl;

cout << "a=" << d4getA() << " b=" << d4getB() << endl;

return 0;

}

#include<iostream>

using namespace std;

class Vehicle{

protected:

int wheel;

double weight;

public:

Vehicle(int wl,double wgt):wheel(wl),weight(wgt){

//cout<<"Vehicle()"<<endl;

}

}; 

class Car:virtual public Vehicle{

protected:

int passengers;

public:

Car(int wl,double wgt,int ps):passengers(ps),Vehicle(wl,wgt){

//cout<<"Car()"<<endl;

}

};

class Truck:virtual public Vehicle{

protected:

double payload;

public:

Truck(int wl,double wgt,double pl):payload(pl),Vehicle(wl,wgt){

//cout<<"Truck()"<<endl;

}

};

class Notchback:public Car,public Truck{

int flag;

public:

Notchback(int wl,double wgt,int ps,double pl,int f):flag(f),Vehicle(wl,wgt),Car(0,0,ps),Truck(0,0,pl){

if(flag==0) cout<<"Notchback constructs from Car"<<endl;

else cout<<"Notchback constructs from Truck"<<endl;

}

};

int main(){

cout<<"nb1:"<<endl;

Notchback nb1(2,3,6,2,0);

cout<<"nb2:"<<endl;

Notchback nb2(2,3,6,2,1);

}

注：

nb1为flag为0，从Car类继承

nb2为flag为非0数，从Truck类继承

可以，举个例子Item_base是

基类

,

虚函数

叫net_price

Item_base

baseP=&derived;

double

d=baseP->Item_base::net_price(42);