C，C++如何使用交叉编译(写一个自定义基类）！

        假设有一个基类Object，Object类会用到String类，而

String类又从Object类派生而来，应该怎样定义，看下面:

Object.h

#pragma once
 
 
class String;        //string前置定义

/// <summary>
/// Object类定义
/// </summary>
class Object
{
public:
	virtual String ToString()const;
 

};

Object.cpp 

#include "Object.h"
#include "String.h"

 

String Object::ToString() const
{
    return String();
}

String.h

#pragma once

#include "Object.h"
 

class String : public Object
{
public:
	String();
};

String.cpp

#include "String.h"
#include "Object.h"


String::String()
{

}

现在，同理，加一个链表，数组：

#pragma once
 
 
class String;        //std:string前置定义
class List;
class ByteArray;

/// <summary>
/// Object类定义
/// </summary>
class Object
{
public:
	String ToString()const;
 

};

class List : public Object

{

}

class ByteArray : public Object

{

        

}

但是有一点，你不能把Object定义为模拟类，因为模板类都要在

头文件中实现：

 
class String;        //std:string前置定义
class List;
class ByteArray;

tempalte<class T>

class Object

{

public:

        String ToString()  const

        {

                return String();

        }

}

结果：错误：使用了未定义的String。

下面是我Object类的例子：

_Object.h

/*******************************************************************************************
文件名						： Object.h

功能							： object 类

作者							： 李锋

手机							： 13828778863

Email						： ruizhilf@139.com

创建时间						： 2022年11月01日




最后一次修改时间				： -------------------------------------------------2023年03月27日

 (1) 如果类定义中有指针或引用变量或对象，为了避免潜在错误，最好重载拷贝构造函数和赋值函数。
 (2) 如果使你的类能够给其它可以排序功能的类使用，就必须重载 < > == 运算符
*********************************************************************************************/
#ifndef __OBJECT_H_
#define __OBJECT_H_


#include "_Macro.h"

_LF_BEGIN_

//#define _OBJECT_DEBUG_

//-----------------------------------------------------前置声明
class _ByteArray;
class _StrW;
class _StrA;
 
/// <summary>
/// 不命名 _Object ，是因为跟 System::Object 同名
/// </summary>
class _Object
{
private:
	/// <summary>
	/// _Object 对象计数器
	/// </summary>
	static __int64 _iObjectCount;

	/// <summary>
	/// 是否进行全局初始化
	/// </summary>
	static bool _bInitializeGlobal;

protected:

	//inline virtual void InitData(const int& nBuffer, const int& nDefaultBuffer = 15) {};
	//inline virtual void InitData() {};

public://----------------------------------------------构造析构
	_Object();
	virtual ~_Object();	 

public://----------------------------------------------重写接口

	/// <summary>
	/// 清空数据
	/// </summary>
	/// 创建时间：2022-11-13    最后一次修改时间：2022-11-13
	inline virtual void ClearData() {};


	/// <summary>
	/// 清空内存，重置为实始化状态
	/// </summary>
	inline virtual void ClearMemory() {};

 

	/// <summary>
	/// 返回用字符串表示的对象，如splitString分隔字符串不等于空，则每个对象用splitString分隔。
	/// </summary>
	/// <param name="splitString">分隔字符串</param>
	/// <returns>返回用字符表示的对象</returns>
	/// 创建时间：2022-11-13    最后一次修改时间：2023-05-14
	virtual _string ToSplitString(const _string &splitString) const;
	

	/// <summary>
	/// 返回用字符串表示的对象，实际是返回虚拟函数 return ToSplitString(_t(""));
	/// </summary>
	/// <returns></returns>
	/// 创建时间：2023-05-15    最后一次修改时间：2023-05-15
	_string ToString()const;

 
	 
	/// <summary>
	/// 把对象保存在内存中。
	/// </summary>
	/// <returns></returns>
	/// 创建时间：2022-11-13    最后一次修改时间：2023-03-12
	inline virtual  _ByteArray& PackageMemory(_ByteArray& baPackageMem) const;

 

	/// <summary>
	/// 从内存中读出对象
	/// </summary>
	/// <param name="pPackageMem">指向数据的指针</param>
	/// <param name="nStart">开始读出的位置</param>
	/// 创建时间：2022-11-13    最后一次修改时间：2023-03-12
	inline virtual void SplitFromMemory(const _byte* pPackageMem, const _uint nStart = 0);

	/// <summary>
	/// 如果大于 oRight 则返回1，等于返回0，小于返回-1
	/// </summary>
	/// <param name="oRight"></param>
	/// <returns></returns>
	/// 创建时间：2022-11-13    最后一次修改时间：2022-11-13
	virtual int CompareTo(const _Object& oRight)const;


	/// <summary>
	/// 释放本身内存，托管新的内存。
	/// </summary>
	/// <param name="pData"></param>
	/// <param name="nDataMemoryLength">数据长度</param>
	/// <param name="nMemoryLength">使用内存长度</param>
	/// 创建时间：2023-01-04    最后一次修改时间：2023-01-05
	virtual void TrusteeshipMem(const _byte* pData, const int nDataMemoryLength, const int& nMemoryLength);


	/// <summary>
	/// 除非内存给其它对象托管，否则不要调用这个函数。
	/// 放弃对象当前使用的内存，可能内存已托管给别的对象，
	/// 重新初始化当前对象
	/// </summary>
	/// 创建时间：2023-01-04    最后一次修改时间：2023-01-05
	inline virtual void GiveUppMem(){}


	/// <summary>
	/// 返回对象所使用的内存大小，以Byte计数。
	/// </summary>
	/// <returns></returns>
	/// 创建时间：2023-01-04    最后一次修改时间：2023-01-05
	inline virtual int GetMemoryLength() { return 0; }

	/// <summary>
	/// 返回对象数据所使用的内存大小，以Byte计数。
	/// </summary>
	/// <returns></returns>
	/// 创建时间：2023-01-04    最后一次修改时间：2023-01-05
	inline virtual int GetDataMemoryLength() { return 0; }

public: 
	//-----------------------------------------------------------------运算符重载


	/// <summary>
	/// 这个函数的意义在于，每个从继承自 _Object 类，都可以转换成 _string
	/// </summary>
	/// 创建时间：2022-11-13    最后一次修改时间：2022-11-13
	operator _string();



	/// <summary>
	/// 强制转换为String
	/// </summary>
	/// 创建时间：2023-04-29    最后一次修改时间：2023-04-29
	operator _stdstr()const;
 


	inline friend bool operator > (const _Object& oLeft, const _Object& oRight) { return oLeft.CompareTo(oRight) == 1; }
	inline friend bool operator < (const _Object& oLeft, const _Object& oRight) { return oLeft.CompareTo(oRight) == -1; }
	inline friend bool operator == (const _Object& oLeft, const _Object& oRight) { return oLeft.CompareTo(oRight) == 0; }
public:
	/// <summary>
	/// 从文件中读取数据
	/// </summary>
	/// 创建时间：2023-03-14   最后一次修改时间：2023-03-14
	void ReadDataFromFile(const _string& sFullPathName);

	/// <summary>
	/// 把数据保存在文件中
	/// </summary>
	/// 创建时间：2023-03-14   最后一次修改时间：2023-03-14
	void SaveDataToFile(const _string& sFullPathName);


	/// <summary>
	/// 获取一个文件名
	/// </summary>
	/// 创建时间：2023-03-14   最后一次修改时间：2023-03-14
	_string GetFilePathName()const;

public://----------------------------------------------------------------属性 
	inline static __int64 GetObjectCount() { return _iObjectCount; }
	__declspec(property(get = GetObjectCount)) __int64  ObjectCount;



	 _string GetTypeName() const;

	/// <summary>
	/// 
	/// </summary>
	__declspec(property(get = GetTypeName)) const _string ClassName;
	
};



_LF_END_


#endif

_Object.cpp

#include "_Object.h"
#include "_Debug.h"
#include "global_c_all.h"

_LF_BEGIN_

 

_int64 _Object::_iObjectCount = 0;
bool _Object::_bInitializeGlobal = false;

 

_Object::_Object()
{
#ifdef _OBJECT_DEBUG_
	_cout << _t("_Object::_Object()\n");
#endif
	++_iObjectCount;

	if (!_bInitializeGlobal) {

		setlocale(LC_ALL, "Chinese-simplified");//设置中文环境

		_bInitializeGlobal = true;
	}	 
}

_Object::~_Object()
{
#ifdef _OBJECT_DEBUG_
	_cout << _t("_Object::~_Object()\n");
#endif
	--_iObjectCount;

	ClearData();
}

_string _Object::ToSplitString(const _string& splitString) const
{
	_string sInfo = this->ClassName;
	sInfo.Add(_t("未重写虚拟函数_string _Object::ToSplitString(const _string& splitString) const"));

	return sInfo;
}


_string _Object::ToString() const
{
	return ToSplitString(_t(""));
}

 

_ByteArray& _Object::PackageMemory(_ByteArray& baPackageMem) const
{
	// TODO: 在此处插入 return 语句

	return baPackageMem;
}


/// <summary>
/// 从内存中读出对象
/// </summary>
/// <param name="pPackageMem">指向数据的指针</param>
/// <param name="nStart">开始读出的位置</param>
/// 创建时间：2022-11-13    最后一次修改时间：2023-03-12
void  _Object::SplitFromMemory(const _byte* pPackageMem, const _uint nStart)
{
	// TODO: 在此处插入 return 语句
	 
}

int _Object::CompareTo(const _Object& oRight) const
{
	_cout << _t("定义的对象：") << GetTypeName() + _t("需要重写虚拟函数 virtual int CompareTo(const _Object& oRight)\n");

	return 1;
}

void _Object::TrusteeshipMem(const _byte* pData, const int nDataMemoryLength, const int& nMemoryLength)
{
	ClearMemory(); 
}

 
_Object::operator _string()
{
	 return ToSplitString(_string());
}

_Object::operator _stdstr() const
{
	return ToSplitString(_string()).std_c_str();
}
 
/// <summary>
/// 从文件中读取数据
/// </summary>
/// 创建时间：2023-03-14   最后一次修改时间：2023-03-14
void _Object::ReadDataFromFile(const _string& sFullPathName)
{
	if (ga.gcf_FileExisits(sFullPathName))
	{
		_ByteArray ba;
		ba.ReadFromFile(sFullPathName);
		this->SplitFromMemory(ba.Data);
	}
	else
	{
		d.ShowError(sFullPathName + _t(" 文件不存在！"));
	}
}


/// <summary>
/// 把数据保存在文件中
/// </summary>
/// 创建时间：2023-03-14   最后一次修改时间：2023-03-14
void _Object::SaveDataToFile(const _string& sFullPathName)
{
	if (ga.gcf_FileExisits(sFullPathName))
	{
		_ByteArray ba;
		this->PackageMemory(ba);
		ba.WriteToFile(sFullPathName);
	}
	else
	{
		d.ShowError(sFullPathName + _t(" 文件不存在！"));
	}
}

/// <summary>
/// 获取一个文件名
/// </summary>
/// 创建时间：2023-03-14   最后一次修改时间：2023-03-14
_string _Object::GetFilePathName()const
{
	_string sName = ClassName;

	int n = sName.IndexOf(_t("::"));

	if ( n != -1)
	{
		sName = sName.SubStr(n + 2, sName.Length - n - 2);
	}
	else
	{
		n = sName.IndexOf(_t(" "));
		sName = sName.SubStr(n + 1, sName.Length - n - 1);
	}



	return  ga.dataPath + sName + _t(".dat");
}


_string _Object::GetTypeName()const
{

#ifdef _UNICODE_		

	std::wstring wText = gs.s_UTF8String_to_TextW(typeid(*this).name());

	#ifdef _USE_LF_
		return wText.c_str();
	#else
		return wText;
	#endif
#else
 
	return typeid(*this).name();
#endif

}






/*

//------------------------------------------------------------------------------------CSharp
bool _Object::CSharp_Equals(const _Object& obj)
{
	return false;
}

bool _Object::CSharp_Equals(const _Object& objA, const _Object& objB)
{
	return false;
}

void _Object::Finalize()
{
}

int _Object::CSharp_GetHashCode()
{
	return 0;
}

Type_ _Object::CSharp_GetType()
{
	return Type_();
}


_Object& _Object::CSharp_MemberwiseClone()
{
	
	return *this;
}



bool _Object::CSharp_ReferenceEquals(const _Object& objA, const _Object& objB)
{
	return false;
}

_string _Object::CSharp_ToString()
{
	return _string();
}


*/












_LF_END_