#include <iostream>
using namespace std;
class A
{
public:
int x;
void show()
{
cout<<"A"<<endl;
}
};
class B:public A
{
public:
int y;
void show()
{
cout<<"B"<<endl;
}
};
int main(int argc, const char * argv[])
{
A a,*a1;
B b,*b1;
b = a;//父类不能复制给子类
a = b;//子类可以给父类
a1 = &b;
b1 = &a; //不可以
return 0;
}
//
// main.cpp
// C++test
//
// Created by 丁小未 on 13-7-17.
// Copyright (c) 2013年 dingxiaowei. All rights reserved.
//
#include <iostream>
using namespace std;
class A
{
public:
void show()
{
cout<<"A"<<endl;
}
};
class B:public A
{
public:
void show()
{
cout<<"B"<<endl;
}
};
int main(int argc, const char * argv[])
{
A *a;
A aa;
B b;
a=&b;
aa=b;
aa.show();
return 0;
}
输出结果：
A
#include <iostream>
using namespace std;
虚函数的应用：
class A
{
public:
virtual void show();
virtual void show1()
{
cout<<"A1"<<endl;
}
};
void A::show()
{
cout<<"A\n";
}
class B:public A
{
public:
void show()
{
cout<<"B\n";
}
};
class C:public A
{
public:
void show()
{
cout<<"C\n";
}
virtual void show1()
{
cout<<"C1"<<endl;
}
};
int main()
{
A *a;
B b;
C c;
a=&b;
a=&c;
a->show(); //调用的是C，基类是虚函数，那么子类该同名函数都是虚函数，就调子函数
a->show1(); //还是调用的a，跟子类是否是虚函数没有关系 //如果基类中函数不是虚函数，那么这样就是访问的是基类中的函数，如果加上了virtual那么访问的就是指针所指向的函数
return 0;
}
纯虚函数：virtual void show() = 0;//纯虚基类函数不实现具体的行为，实现完全有接口来实现，函数名赋予0，本质上是将指向函数的的指针，纯虚函数必须要实现，成为重载纯虚函数。
成员函数被重载的特征
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
覆盖是指派生类函数覆盖基类函数，特征是
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）
#include <iostream>
usingnamespacestd;
class Sample{
public:
Sample(){ cout<<"Constructor"<<endl;}
~Sample(){cout<<"Destructor"<<endl;}
};
void fun(int i)
{staticSample c;
cout<<"i="<<i<<endl;
}
int main(void)
{fun(10);
fun(20);
return0; //静态对象只初始化一次
}
运行结果：
Constructor
10
20
Destructor
//注意
#include <iostream>
usingnamespacestd;
class Tc {
private:
int A;
staticint B;//静态数据成员
public:
Tc(int a)
{
A=a;
B+=a;
}
staticvoid display(Tc c);//Tc的对象为形参
};
void Tc::display(Tc c)//不用static修饰
{
cout<<"A="<<c.A<<",B="<<B<<endl;
}
intTc::B=2;
int main(void)
{Tc a(2),b(4);
Tc::display (a);
Tc::display (b);
return0;
}
运行结果： //解释：创建两个对象的时候，调用了两次构造函数，但static只创建一次
A=2,B=8;
A=4,B=8;
class A
{
friend class B;
}
那么B就是A的有元
