011_multiderivedwithVir.cc
#include <iostream>
using std::cout;
using std::endl;
//------------------------------//
class A{
public:
virtual void a(){ cout << "A::a()" << endl; }
virtual void b(){ cout << "A::b()" << endl; }
virtual void c(){ cout << "A::c()" << endl; }
};
//------------------------------//
class B{
public:
virtual void a(){ cout << "B::a()" << endl; }
virtual void b(){ cout << "B::b()" << endl; }
void c(){ cout << "B::c()" << endl; }
void d(){ cout << "B::d()" << endl; }
};
//------------------------------//
class C
: public A
, public B
{
public:
virtual void a(){ cout << "C::a()" << endl; }
void c() override{ cout << "C::c()" << endl; }
//能加 覆盖
void d(){ cout << "C::d()" << endl; }
};
//2 表
//A C::a() C::c() B C::c()
//d()
//------------------------------//
//先不看D类
class D
: public C
{
public:
void c(){ cout << "D::c()" << endl; }
//如果 D::c()是虚函数,覆盖虚表C::c()
//那么C*通过虚表访问,只能访问到 D::c()
//
//如果D::c()是造成基类同名函数隐藏
//那么C*指针访问,会访问到基类的函数C::c()??(鬼知道
};
void test(){
/* D c; */
C c;
c.a();//C::a() 隐藏
c.c();//C::c() 隐藏
c.d();//C::d() 隐藏,d对于C是普通成员函数
/* c.b(); //成员名访问冲突二义性 */
cout<<endl;
A* pa=&c;
pa->a();//C::a() 动态多态
pa->b();//A::b() 没有覆盖,会通过虚函数表
pa->c();//C::c() 动态多态
/* pa->d();//A类没有定义d函数,无法调用 */
cout << endl;
B* pb = &c;
pb->a(); //C::a() 多态
pb->b(); //B::b() 没有覆盖,虚表
pb->c(); //B::c() 普通函数c()
pb->d(); //B::d() 普通函数d()
cout << endl;
C * pc = &c;
pc->a(); //C::a() 通过虚表,没有触发动态多态
/* pc->b(); */ //访问二义性
pc->c(); //C::c() 本质是虚函数,通虚表,没有触发动态多态
pc->d(); //C::d() 隐藏 没有多态
cout << endl;
D d1;
C * pd = &d1;
pd->c(); //D::c()
}
int main(void)
{
test();
return 0;
}
heckVtableAddress.cc
#include <iostream>
using std::cout;
using std::endl;
//-------------------------------//
class Base{
public:
virtual void print() {
cout << "Base::print()" << endl;
}
virtual void display() {
cout << "Base::display()" << endl;
}
virtual void show() {
cout << "Base::show()" << endl;
}
private:
long _base = 10;
};
//-------------------------------//
class Derived
: public Base
{
public:
virtual void print() {
cout << "Derived::print()" << endl;
}
virtual void show() {
cout << "Derived::show()" << endl;
}
virtual void display() {
cout << "Derived::display()" << endl;
}
private:
long _derived = 100;
};
//-------------------------------//
void test(){
cout<<sizeof(Base)<<endl;
cout<<sizeof(Derived)<<endl;
//16(8+8) 24(8+16)
Derived d1;
long* pD=(long*)(&d1);
//验证虚表 文字常量区 一个类一张表
//----------------------------------//
/* static int num=10; */
const char* b="hello";
/* cout<<&num<<endl; */
cout<<&b<<endl;
cout<<endl;
cout<<pD<<endl;
Derived d2;
long *pdd=(long*)(&d2);
cout<<pdd<<endl;
cout<<pD[0]<<endl;
cout<<pdd[0]<<endl;
cout<<"one class one table"<<endl;
//----------------------------------//
cout<<endl;
cout<<pD[0]<<endl;
cout<<pD[1]<<endl;
cout<<pD[2]<<endl;
//用C的方式 拆解内存布局 只关注内存
cout<<endl;
long* pVatable=(long*)(pD[0]);//指针指向三个连续的内存空间
cout<<pVatable[0]<<endl;
cout<<pVatable[1]<<endl;
cout<<pVatable[2]<<endl;
//虚表的三个元素 是函数指针
cout<<endl;
typedef void (*func)();
func f=(func)(pVatable[0]);
f();
f=(func)(pVatable[1]);
f();
f=(func)(pVatable[2]);
f();
//虚表顺序 根据基类定义顺序
}
int main(void)
{
test();
return 0;
}
DiamondConstructor.cc
#include <iostream>
using std::cout;
using std::endl;
//-------------------------------------------//
class A
{
public:
A(double a)
: _a(a)
{cout << "A(double)" << endl;}
~A(){cout << "~A()" << endl;}
private:
double _a = 10;
};
//-------------------------------------------//
class B
: virtual public A
{
public:
B(double a, double b)
: A(a)
, _b(b)
{cout << "B(double,double)" << endl;}
~B(){ cout << "~B()" << endl; }
private:
double _b;
};
//-------------------------------------------//
class C
: virtual public A
{
public:
C(double a, double c)
: A(a)
, _c(c)
{
cout << "C(double,double)" << endl;
}
~C(){ cout << "~C()" << endl; }
private:
double _c;
};
//-------------------------------------------//
class D
: public B
, public C
{
public:
D(double a,double b,double c,double d)
: A(a)
, B(a,b)
, C(a,c)
, _d(d)
//虚拟继承的结构中,最底层需要显示调用中间层,最底层基类的构造函数
//A类构造压抑BC类构造调用A类构造
{
cout << "D(double * 4)" << endl;
}
~D(){ cout << "~D()" << endl; }
private:
double _d;
};
//-------------------------------------------//
void test(){
cout<<sizeof(A)<<endl; //double
cout<<sizeof(B)<<endl; //A+p double
cout<<sizeof(C)<<endl; //A+p double
cout<<sizeof(D)<<endl; //b/double+p c/double+p double A
cout<<endl;
//A B C D
D(1,2,3,4);
//~D ~C ~B ~A
}
int main(void)
{
test();
return 0;
}
013_abab.cc
#include <iostream>
using std::cout;
using std::endl;
//-------------------------------//
class A {
public:
virtual void foo() { std::cout << "A::foo()" << std::endl; }
virtual void bar() { std::cout << "A::bar()" << std::endl; }
virtual void baz() { std::cout << "A::baz()" << std::endl; }
virtual ~A() {}
double a=10;
};
//-------------------------------//
class B : public virtual A {
public:
virtual void foo() override { std::cout << "B::foo()" << std::endl; }
virtual void bar() override { std::cout << "B::bar()" << std::endl; }
virtual void qux() { std::cout << "B::qux()" << std::endl; }
double b=20;
};
//-------------------------------//
class C : public virtual A {
public:
virtual void baz() override { std::cout << "C::baz()" << std::endl; }
virtual void quux() { std::cout << "C::quux()" << std::endl; }
double c=30;
};
//-------------------------------//
class D : public B, public C {
public:
virtual void foo() override { std::cout << "D::foo()" << std::endl; }
virtual void bar() override { std::cout << "D::bar()" << std::endl; }
virtual void qux() override { std::cout << "D::qux()" << std::endl; }
virtual void quux() override { std::cout << "D::quux()" << std::endl; }
double d=40;
};
void test(){
cout<<sizeof(A)<<endl; //double/a +vf->A 16
cout<<sizeof(B)<<endl; //double/b +vf->B +vb->A 32
cout<<sizeof(C)<<endl; //double/c +vf->C +vb->A 32
cout<<sizeof(D)<<endl; //double/a/b/c/d vf->D vb->B/C 56
cout<<endl;
}
int main(void)
{
test();
return 0;
}
作业
01 根据给定的程序,写出执行结果 (1,2)(6,9)5,6
#include <iostream>
using std::endl;
using std::cout;
//------------------------------//
class A
{
public:
A(int i,int j){
a=i;
b=j;
}
void move(int i,int j) {
a += i;
b += j;
}
void disp() { cout << "(" << a << "," << b << ")" << endl;}
private:
int a,b;
};
//------------------------------//
class B
: public A
{
public:
B(int i,int j,int k,int l)
:A(i,j)
,x(k)
,y(l)
{ }
void disp(){cout << x << "," << y << endl;}
void fun() {move(3,5);}
private:
int x,y;
};
//------------------------------//
int main()
{
A m(1,2);
m.disp();//(1,2)
B d(3,4,5,6);
d.fun();//6,9,5,6
d.A::disp();//(6,9)
d.disp();//5,6
return 0;
}
02 根据给定的程序,写出执行结果 --Base1--Base2--Derived--Base2--
#include<iostream>
using std::endl;
using std::cout;
//------------------------------//
class Base1
{
public:
virtual void fun(){cout<<"--Base1--\n"; }
};
//------------------------------//
class Base2
{
public:
void fun(){cout<<"--Base2--\n"; }
};
//------------------------------//
class Derived
:public Base1
,public Base2
{
public:
void fun(){cout<<"--Derived--\n";}
};
int main()
{
Base1 obj1, *ptr1;
Base2 obj2, *ptr2;
Derived obj3;
ptr1=&obj1;
ptr1->fun();//--Base1
ptr2=&obj2;
ptr2->fun(); //---Base2
ptr1=&obj3;
ptr1->fun(); //--Base3
ptr2=&obj3;
ptr2->fun(); //--Base2
return 0;
}
03 根据给定的程序,写出执行结果 ABBAB
#include <iostream>
using std::cout;
using std::endl;
//------------------------------//
class A
{
public:
void FuncA(){printf( "FuncA called\n" );}
virtual void FuncB(){printf( "FuncB called\n" );}
};
//------------------------------//
class B
: public A
{
public:
void FuncA(){
A::FuncA();
printf( "FuncAB called\n" );
}
virtual void FuncB(){printf( "FuncBB called\n" );}
};
//------------------------------//
void test(){
B b;
A *pa;
pa = &b;//*A->B
A *pa2 = new A; //*A->A
pa->FuncA();// FuncA called //fugai
pa->FuncB();// FuncBB called
pa2->FuncA(); //FuncA called
pa2->FuncB(); //FuncB called
delete pa2;
}
int main(void)
{
test();
return 0;
}
04 根据给定的程序,写出执行结果 12
#include <iostream>
using std::cout;
using std::endl;
//------------------------------//
class Base
{
public:
Base(int j)
: i(j)
{}
virtual ~Base() {}
void func1() {
i *= 10;
func2();
}
int getValue(){return i;}
protected:
virtual void func2(){i++;}
protected:
int i;
};
//------------------------------//
class Child
: public Base
{
public:
Child(int j)
: Base(j)
{}
void func1(){
i *= 100;
func2();
}
protected:
void func2(){i += 2;}
//覆盖
};
//------------------------------//
void test(){
Base * pb = new Child(1);
//Base *->Child
pb->func1();
//i*=10 +=2 12
cout << pb->getValue() << endl;
//12
delete pb;
}
int main(void)
{
test();
return 0;
}
05 实现C++ primer 15.9中的文本查询扩展的作业,可以查某个单词在某行出现、某个单词在某行没有出现、某两个单词在某行出现、某两个单词至少有一个出现、三个单词的查询等等。(即实现查询单词的与、或、非操作)