C++ 使用静态类实现跨类调用

最近看代码,发现一个很好用但是我一直不知道的东西.

就是在C++中一个类调用另外一个类的函数.A类像调用B类的函数,并且要打印B类中的数据.

当然方法有很多.

第一种方法:比如在A类中实例化B类,但是需要另外类的数据,实例化就不行,因为重新搞了一个对象.数据什么都没有了.

第二种方法:在A类中接收B类的指针实现,优点是好理解,缺点是,你得能找到B类的指针,并且接收到B类指针.

第三种方法:A类继承B类,当然,要是两个类没什么关系,继承显得如此不协调.

第四种:就是我最近看到的使用静态方法,A类调用B类的函数和数据.

第一种方法,A类实例化B类代码:

main函数:

#include "stdafx.h"
#include <iostream>
#include <string>
#include "egg.h"
#include "A.h"
#include "B.h"
using namespace std;

int main()
{
	A a;
	B b(10);
	cout << "B实例的数据" << b.print() << endl;
	b.printAddr();
	cout << "A类调用B类:" << endl;
	cout << "A重新实例化B的数据" <<a.print() << endl;
    return 0;
}

A类代码:

#pragma once
#include "B.h"

class A
{
public:
	A();
	~A();
	int print()
	{
		B b(47);
		b.printAddr();
		return b.print();		
	}
};

B类代码:

#pragma once
#include <iostream>
class B
{
public:
	B(int I) :i(I) {};
	~B() {};
	int i;
	int print() { return i; }
	void printAddr() { std::cout << "B类的地址: " << this << std::endl; }
};

结果:

 第二种方法A类接收B类指针:

main函数代码:

#include "stdafx.h"
#include <iostream>
#include <string>
#include "egg.h"
#include "A.h"
#include "B.h"
using namespace std;

int main()
{	A a;
	B *b = new B(10);
	cout << "B实例的数据" << b->print() << endl;
	b->printAddr();
	cout << "A类调用B类:" << endl;
	cout << "A重新实例化B的数据" <<a.print(b) << endl;
    return 0;
}

B类函数:

#pragma once
#include <iostream>
class B
{
public:
	B(int I) :i(I) {};
	~B() {};
	int i;
	int print() { return i; }
	void printAddr() { std::cout << "B类的地址: " << this << std::endl; }
};

A类函数:

#pragma once
#include "B.h"

class A
{
public:
	A();
	~A();
	int print(B* b)
	{
		b->printAddr();
		return b->print();		
	}
};

结果:

 把指针换成引用也可以,效果也一样,但是原理不一样.

其中B类代码不动,main代码和A类改一下；

main函数:

#include "stdafx.h"
#include <iostream>
#include <string>
#include "egg.h"
#include "A.h"
#include "B.h"
using namespace std;

int main()
{
	A a;
	B *b = new B(10);
	cout << "B实例的数据" << b->print() << endl;
	b->printAddr();
	cout << "A类调用B类:" << endl;
	cout << "A重新实例化B的数据" <<a.print(*b) << endl;
    return 0;
}

A类函数:

#pragma once
#include "B.h"

class A
{
public:
	A();
	~A();
	int print(B& b)
	{
		b.printAddr();
		return b.print();		
	}
};

第三种方法:A类继承B类:

这个就不讨论了,跟本次主题不符合;

第四种方法:使用静态方法,A类调用B类的函数和数据

静态方式有两种:

第一种是返回类指针的方式,

第二种是实例化时,构造函数把this指针传给static指针.

先看第一种:

main函数

#include "stdafx.h"
#include <iostream>
#include <string>
#include "egg.h"
#include "A.h"
#include "B.h"
using namespace std;
B B::b(10);
int main()
{
	A a;	
	cout << "B实例的数据" << B::b.print() << endl;
	B::b.printAddr();
	cout << "A类调用B类:" << endl;
	cout << "A重新实例化B的数据" <<a.print() << endl;
    return 0;
}

B类

#pragma once
#include <iostream>
class B
{	
public:
	static B b;
	B(int I) :i(I) {};
	~B() {};
	int i;
	int print() { return i; }
	static B* instance() { return &b; }
	void printAddr() { std::cout << "B类的地址: " << this << std::endl; }
};

A类:

#pragma once
#include "B.h"

class A
{
public:
	A();
	~A();
	int print()
	{
		B::instance()->printAddr();
		return B::instance()->print();
	}
};

结果

 第二种方法:

main函数:

#include "stdafx.h"
#include <iostream>
#include <string>
#include "A.h"
#include "B.h"
using namespace std;
B* B::Instance = 0;
B b(47);

int main()
{
	A a;	
	cout << "B实例的数据" << B::Instance->print() << endl;
	B::Instance->printAddr();
	cout << "A类调用B类:" << endl;
	cout << "A重新实例化B的数据" <<a.print() << endl;
    return 0;
}

B类:

#pragma once
#include <iostream>
class B
{	
public:
	static B* Instance;
	B(int I) :i(I) { Instance = this; };
	~B() {};
	int i;
	int print() { return i; }	
	void printAddr() { std::cout << "B类的地址: " << this << std::endl; }
};

A类:

#pragma once
#include "B.h"

class A
{
public:
	A();
	~A();
	int print()
	{
		B::Instance->printAddr();
		return B::Instance->print();
	}
};

结果:

 总结:

第一种方法调用好理解,但是不实用,因为重新实例化的,B类的数据得不到,第二种和第三种方法都可以得到B类数据,因为拿到了B类的地址,第一种方法没有拿到地址.看需求使用.应该不只是这几种方法,还有其他的使用技巧,我现在还不会,在以后看代码的过程中在总结吧.