C++_test_08

1.虚函数
2.友员函数，并用代码实现
3.友员类，并用代码实现。
4.互为友员类，并用代码实现。

虚函数(virtual)

1. 不能修饰构造函数
2. 实现多态，防止调用时失去派生类的作用
3. 修饰不可以多复用，修饰谁，谁有用

示例

#include<iostream>
using namespace std;

//间接基类A
class A {
protected:
    int m_a;
};

//直接基类B
class B : virtual public A {
protected:
    int m_b;
};

//直接基类C
class C : virtual public A {
protected:
    int m_c;
};

//派生类D
class D : public B, public C {
public:
    void seta(int a) { m_a = a; }  //不加virtual->命名冲突
    void setb(int b) { m_b = b; }  //正确
    void setc(int c) { m_c = c; }  //正确
    void setd(int d) { m_d = d; }  //正确
private:
    int m_d;
};

int main() {
    D d;
    return 0;
}

参考链接

友员函数

• friend在类中，但是不属于类，属于函数，可以合理访问类的私有成员变量
• friend只能写在类中

示例

#include<iostream>
using namespace std;

class A
{
public:
	friend void fun(A a) {
		cout << a.m_a << endl;
	}
private:
	string m_a="I am private";
};


int main() {
	A a;
	fun(a);
    return 0;
}

友员类

#include<iostream>
using namespace std;

class Girlfriend
{
public:
	Girlfriend() {
		secreat = "I am secreat";
	}

private:
	string secreat;
	friend class Mom; //友员类
};

class Mom
{
public:
	void Ican(Girlfriend g) {
		cout<< g.secreat<<endl;
	}

private:

};

int main() {
	Girlfriend girl;
	Mom m;
	m.Ican(girl);
	system("pause");
    return 0;
}

互为友员类

• 函数写在外面，且要放在所有类的下面

#include<iostream>
using namespace std;
class Mom;

class Girlfriend
{
private:
	string secreat;
	friend class Mom; //mom的友员类

public:
	Girlfriend();
	void Ican_MomSecreat(Mom m);
};

class Mom
{
public:
	Mom();
	void Ican_GirlSecreat(Girlfriend g);
private:
	string mom_secreat;
	friend class Girlfriend; //Girlfriend的友员类
};

Mom::Mom() {
	mom_secreat = "I am mom_secreat";
}

void Mom::Ican_GirlSecreat(Girlfriend g) {
	cout << g.secreat << endl;
}

Girlfriend::Girlfriend() {
	secreat = "I am girl_secreat";
}

void Girlfriend::Ican_MomSecreat(Mom m) {
	cout << m.mom_secreat << endl;
}


int main() {
	Mom mom;
	Girlfriend girl;
	girl.Ican_MomSecreat(mom);
	cout << "---------" << endl;
	mom.Ican_GirlSecreat(girl);
	system("pause");
	return 0;
}