函数，类和对象

#include <iostream>

using namespace std;

//类与对象：类是某类事物抽象的集合，对象是类的实例化。

//public：公有成员，能被类的所有对象访问，能够被派生类继承，直接使用

//private：私有成员，不能够被任何对象访问，只能在类中的方法访问，同时也不能被派生的子类继承，友函数除外

//protected：保护成员：不能被外界对象访问，但是派生类可以继承

//模板的声明和实例化：template<class C>

//typedef 目的类型表示的类型类型的自定义名称

class CDog //定义的一个dog的父类

{

public:

CDog();//构造函数，类的对象在调用这个类的时候，构造函数就会立刻运行，派生的类的对象使用时，也会先运行这个函数

CDog(int age){};//重载构造函数，自定义的构造函数

~CDog();//析构函数，类的对象在调用完这个类的时候，析构函数就会运行，派生类的对象使用结束后先运行父类的这个析构函数

//CDog(CDog &theDog);//复制构造函数，生成一个对象的复制，参数是类的对象的常量引用

void Growl();//一般的父类的公有成员，子类可以使用，但是不能直接修改，可以重载这个函数

virtual void GrowlForTestVirtualFunction();//虚函数，可以在子类中声明并修改，是个动态的重载函数

//virtual void GrowlForTestVirtualFunction() = 0;//纯虚函数，可以只有声明，没有实现，如果一个类包含这个纯虚函数，被称为抽象类。用户只能从抽象类派生子类，而不能声明抽象类对象。

void GrowlForTestRepeatFunciont();//函数重载，可以在子类中声明并修改，是个静态的重载函数，相当于对象访问了这个函数是直接访问这个函数

friend class KeJi;

//CDog operator +(CDog &one);运算符重载，格式：返回类型 operator 运算符(参数)；

protected:

void havebaby();//这个函数能被派生类继承，相当于半透明

private:

int age;

void born();//这个函数不能被任何对象和派生类继承（friend除外），一般是定义一些本类自己用的函数和参数

};

CDog::CDog(CDog &theDog)

{

age = theDog.age;

...

}

class TaiDi;//如果要使用友函数，就必须先声明类的名称

class ErHa:public CDog//dog派生出来的二哈类，public可以换成protected，但是不能是private

{

public://二哈类的公有成员

ErHa();

~ErHa();

virtual void GrowlForTestVirtualFunction();

void GrowlForTestRepeatFunciont();

TaiDi* dogTai;//这里先创建一个对象，可以用于访问友函数

void cooperative();//在这个函数里可以调用友函数

};

class TaiDi:protected CDog

{

public:

TaiDi();

~TaiDi();

void havebabytoo();

friend void ErHa::cooperative();//将ErHa类里面的cooperative()函数作为友函数，让cooperative()这个函数可以调用TaiDi类里面的私有成员

private:

void fight();//TaiDi类的私有成员，可以通过友函数被调用

};

class KeJi

{

public:

KeJi();

~KeJi();

CDog dogforKeJi;

void GrowlToKeJi();

void Growlfriendfunction();

};

class xiaonaigou:virtual public CDog//利用虚函数解决多重继承，可以直接使用父类的父类的函数，而不会报错

{

public:

xiaonaigou();

~xiaonaigou();

};

class xiaolanggou:public xiaonaigou//当这个类的对象访问这个函数的时候可以调用其父类的父类的函数

{

public:

xiaolanggou();

~xiaolanggou();

};

CDog::CDog()

{

cout<<"this is CDog's composed fraction"<<endl;

}

CDog::~CDog()

{

cout<<"this is CDog's integer fraction"<<endl;

}

void CDog::Growl()

{

cout<<"wangwang"<<endl;

}

void CDog::GrowlForTestRepeatFunciont()

{

cout<<"wangwang for repeated"<<endl;

}

void CDog::GrowlForTestVirtualFunction()

{

cout<<"wangwang for virtual"<<endl;

}

void CDog::havebaby()

{

cout<<"I have a baby"<<endl;

}

void CDog::born()

{

cout<<"hello world"<<endl;

}

ErHa::ErHa()

{

cout<<"this is ErHa's composed fraction"<<endl;

}

ErHa::~ErHa()

{

cout<<"this is ErHa's integer fraction"<<endl;

}

void ErHa::GrowlForTestVirtualFunction()

{

cout<<"AwoAwo for virtual"<<endl;

}

void ErHa::GrowlForTestRepeatFunciont()

{

cout<<"AwoAwo for repeated"<<endl;

}

void ErHa::cooperative()

{

cout<<"I am ErHa.";

dogTai->fight();

}

TaiDi::TaiDi()

{

cout<<"this is TaiDi's composed fraction"<<endl;

}

TaiDi::~TaiDi()

{

cout<<"this is TaiDi's integer fraction"<<endl;

}

void TaiDi::havebabytoo()

{

cout<<"I am TaiDi.";

havebaby();

}

void TaiDi::fight()

{

cout<<"I want to fight."<<endl;

}

KeJi::KeJi()

{

cout<<"this is KeJi's composed fraction"<<endl;

}

KeJi::~KeJi()

{

cout<<"this is KeJi's integer fraction"<<endl;

}

void KeJi::GrowlToKeJi()

{

cout<<"I am KeJi.";

dogforKeJi.born();//可以调用CDog的私有函数born

}

xiaonaigou::xiaonaigou()

{

cout<<"this is xiaonaigou's composed fraction"<<endl;

}

xiaonaigou::~xiaonaigou()

{

cout<<"this is xiaonaigou's integer fraction"<<endl;

}

xiaolanggou::xiaolanggou()

{

cout<<"this is xiaolanggou's composed fraction"<<endl;

}

xiaolanggou::~xiaolanggou()

{

cout<<"this is xiaolanggou's integer fraction"<<endl;

}

//inline void CDog::Growl() {....}内联函数的使用，就是将这个函数体提到class的函数声明处，函数体简单的适用

int main()

{

CDog wangcai;//声明一个CDog类的对象wangcai

ErHa ergouzi;//声明一个ErHa类的对象ergouzi

TaiDi gouride;

KeJi xiaowang;//声明一个KeJi类的对象xiaowang

xiaonaigou ergoudan;//声明一个xiaonaigou类的对象ergoudan

xiaolanggou xiaogoudan;//声明一个xiaolanggou类的对象xiaogoudan

//wangcai.born();//born()是CDog类的私有成员，不能被对象访问，会报错

wangcai.Growl();

wangcai.GrowlForTestRepeatFunciont();

wangcai.GrowlForTestVirtualFunction();

//wangcai.havebaby();//havebaby是CDog类的保护成员，同样不能被对象访问，只能被子类派生和自己用

//ergouzi.born();

ergouzi.Growl();

ergouzi.GrowlForTestRepeatFunciont();

ergouzi.GrowlForTestVirtualFunction();

ergouzi.cooperative();

//ergouzi.havebaby();

gouride.havebabytoo();//可以使用protected继承的子类调用父类的保护成员的函数

//gouride.havebaby();

//xiaowang.havebaby();

xiaowang.GrowlToKeJi();//利用友元类的方法可以访问CDog类中的私有成员和私有函数

ergoudan.Growl();

xiaogoudan.Growl();

return 0;

}

this is CDog's composed fraction //这是对象wangcai调用类CDog时候的构造函数

this is CDog's composed fraction //这是对象ergouzi调用类ErHa时候访问父类CDog的构造函数

this is ErHa's composed fraction //这是对象ergouzi调用类ErHa时候的构造函数

this is CDog's composed fraction //这是对象gouride调用类TaiDi时候访问父类CDog的构造函数

this is TaiDi's composed fraction //这是对象gouride调用类TaiDi时候的构造函数

this is CDog's composed fraction //同理，KeJi类的父类

this is KeJi's composed fraction //KeJi类的构造函数

this is CDog's composed fraction //xiaonaigou的父类CDog

this is xiaonaigou's composed fraction //xiaonaigou的构造函数

this is CDog's composed fraction //xiaolanggou的父类xiaonaigou的父类CDog的构造函数

this is xiaonaigou's composed fraction //xiaolanggou的父类xiaonaigou的构造函数

this is xiaolanggou's composed fraction //xiaolanggou类的构造函数

wangwang

wangwang for repeated

wangwang for virtual

wangwang //CDog派生的子类调用函数

AwoAwo for repeated //函数的重载之后的调用

AwoAwo for virtual //虚函数的调用

I am ErHa.I want to fight. //友元函数的使用，前半句是ErHa类中cooperative()执行的语句，后半句是TaiDi类中的私有成员fight()的函数

I am TaiDi.I have a baby //TaiDi继承CDog类的保护成员，调用保护成员函数

I am KeJi.hello world //KeJi类是CDog的友元类，可以调用私有成员born()

wangwang //xiaonaigou类的调用函数

wangwang //利用虚函数派生，可以让子类的子类直接调用CDog类中的Growl()而不会报错

this is xiaolanggou's integer fraction //解析函数和构造函数呈现一一对应

this is xiaonaigou's integer fraction