public继承意味着is-a;virtual函数意味着接口必须被继承 none-virtual函数意味着接口和实现都必须被继承。
继承主张，能够施行于base class对象身上的每件事情，也可以施行于derived class对象身上。在正方形和矩形例子中，那样的主张无法保持，所以以public继承塑模它们之间的关系并不正确."
{
public:
virtual void mf1()
= 0;
virtual void mf1(int);
virtual void mf2();
void mf3();
void mf3(double);
private:
int x;
};
class Derived :public Base
{
public:
void mf3();
void mf4();
}; void Test()
{
Derived d;
int x = 1;
d.mf1();
//d.mf1(2); //错误！因为Derived::mf1遮掩了Base::mf1
d.mf2(); //调用的是Base::mf2
d.mf3(); //调用的是Base::mf3
//d.mf3(x); //错误！因为Derived::mf1遮掩了Base::mf3
d.mf4(); //调用的是Derived::mf4
}
calss时附带地从疏远地base classes继承重载函数。不幸地是你通常会想继承重载函数。实际上如果你正在使用public继承而又不继承那些重载函数，就是违反base和derived classes之间地is-a关系。
class Base
{
public:
virtual void mf1()
= 0;
virtual void mf1(int);
virtual void mf2();
void mf3();
void mf3(double);
private:
int x;
};
class Derived :public Base
{
public:
using Base::mf1;
using Base::mf3;
virtual void mf1();
void mf3();
void mf4();
};
void Test()
{
Derived d;
int x = 1;
d.mf1(); //调用的是Derived::mf1
d.mf1(2);
//调用的是Base::mf1
d.mf2(); //调用的是Base::mf2
d.mf3(); //调用的是Base::mf3
d.mf3(x); //调用Base::mf3
d.mf4(); //调用的是Derived::mf4
function),例如我们想在Derived内只使用mf1的午参数版本可以这样来做：
virtual void mf1()
{
Base::mf1();
class IShape
{
private:
int objID;
public:
virtual void draw() const = 0;
virtual void error(const std::string&
msg);
int objectID() const {return objID;}
};
void IShape::draw() const
{
}
class Retangle:public IShape
{
public:
virtual void draw() const;
virtual void error(const std::string&
msg);
};
void Retangle::draw() const
{
//defalut
}
void Retangle::error(const std::string&
msg)
{
}
class Ellipse:public IShape
{
public:
Ellipse();
virtual void draw() const {}
virtual void error(const std::string&
msg){}
void Test()
{
ps1 = new Retangle;
ps1->draw();
IShape *ps2 = new Ellipse;
ps2->draw();
ps1->IShape::draw(); //调用Shape::draw
ps2->IShape::draw(); //调用Shape::draw
class提供的缺省版本。
using namespace std; class GameCharacter
{
public:
int healthValue() const //derived
classes 不重新定义它
{
//....... //做一些事前工作,详下
int reVal = doHealthValue(); //做真正的工作
//...... //做一些事后工作,详下
return reVal;
}
private:
virtual int doHealthValue() const //derived
classes可重新定义它
{
//.... //缺省计算，计算健康指数
}
}; class EvilBadGuy:public GameCharacter
{
public:
virtual int doHealthValue() const
{
cout << "EvilBadGuy
health value." << endl;
}
private:
}; void TestGameCharacter()
{
EvilBadGuy obj;
obj.healthValue();
}
class GameCharacter;
class HealthCalcFunc
{
public:
virtual int calc(const GameCharacter&
gc) const{};
};
HealthCalcFunc defaultHealthCalc;
class GameCharacter
{
public:
explicit GameCharacter(HealthCalcFunc*
phcf=&defaultHealthCalc):pHealthCalc(phcf)
{
}
int healthValue() const
{
return pHealthCalc->calc(*this);
}
private:
HealthCalcFunc* pHealthCalc;
};
class EvilBadGuy : public HealthCalcFunc
{
public:
virtual int calc(const GameCharacter&
gc) const
{
cout << "EvilBadGuy
health value." << endl;
}
};
void TestGameCharacter()
{
EvilBadGuy obj;
GameCharacter gc(&obj);
gc.healthValue();
Method设计模式。
using namespace std;
class B
{
public:
void mf(){cout << "B
class" << endl;}
private:
};
class D:public B
{
public:
void mf(){cout <<"D
class" << endl;}
};
void TestInterface()
{
D x;
B* pb = &x;
D *pd = &x;
pb->mf(); // "B class"
pd->mf(); // "D class"
}
#include <iostream>
using namespace std;
class B
{
public:
virtual void mf(int count=10){cout << "B::count:
" << count << endl;}
private:
};
class D:public B
{
public:
virtual void mf(int count
= 20){cout <<"D::count:
" << count << endl;}
};
void TestInterface()
{
D x;
B* pb = &x;
D* pd = &x;
pb->mf(); // “D::count:
10"
pd->mf(); // "D::count:
20"
class B
{
public:
void mfInterface(int count=10){ mf(count); }
private:
" << count << endl;}
}; class D:public B
{
public:
virtual void mf(int count){cout <<"D::count:
" << count << endl;}
void TestInterface()
{
D x;
B* pb = &x;
D* pd = &x;
pb->mfInterface(); //
"D::count: 10"
pd->mfInterface(); //
"D::count: 10"
class中都会变成private属性，纵使它们在base class中原本是protected或public属性。Private继承意味implemented-in-terms-of(根据某物实现出).