C++自定义类的自动转换

1.内置类型转换为自定义类型

(1) 首先明确内置类型的种类

1> 整形数据：

int：整数类型，通常使用32位（4字节）存储。

short：短整数类型，通常使用16位（2字节）存储。

long：长整数类型，通常使用32位或64位存储，其长度与平台相关。

long long：长长整数类型，通常使用64位（8字节）存储。

2> 浮点数类型：

float：单精度浮点数类型，通常使用32位存储。

double：双精度浮点数类型，通常使用64位存储。

long double：扩展精度浮点数类型，其长度与平台相关。

3> 字符类型：

char：字符类型，通常使用8位（1字节）存储。

wchar_t：宽字符类型，可用于表示更大范围的字符。

char16_t：16位Unicode字符类型。

char32_t：32位Unicode字符类型。

4> 布尔类型：

bool：布尔类型，表示真或假的值。使用true表示真，false表示假。

5> 空类型：

void：空类型，用于表示无类型或无返回值。

(2) 自动转换的意义

C++的语法很完善，如类中函数的重载，相同的逻辑可以支持不同类型的对象执行类似的逻辑。如果一味的重载势必会造成代码的冗余。

遇到这种情况可以使用template去进行二次封装，就能实现代码的一定优化。考虑到模板的使用语法的复杂麻烦，可以对模板部分进行再次封装。

自动转换利用重载的能力，使自身转变成内部成员变量相似的对象。

参考boost::variant实现多类型数据的例子。

#include <string>
#include <iostream>
#include <boost/variant.hpp>
using namespace std;

typedef boost::variant<boost::blank, std::string, int, double, float> PVariant;

class CVariant
{
public:
	CVariant() { m_variant = boost::blank{}; }
	CVariant(char* var) { m_variant = string(var); }
	CVariant(string var) { m_variant = var; }
	CVariant(int var) { m_variant = var; }
	CVariant(double var) { m_variant = var; }
	CVariant(float var) { m_variant = var; }
	~CVariant() {}

public:
	int toInt()
	{
		int val;
		toValue(val, m_variant);
		return val;
	}

	string toString()
	{
		string val;
		toValue(val, m_variant);
		return val;
	}

	double toDouble()
	{
		double val;
		toValue(val, m_variant);
		return val;
	}

	float toFloat()
	{
		float val;
		toValue(val, m_variant);
		return val;
	}

	long toLong()
	{
		return (long)toInt();
	}

	CVariant& operator=(const CVariant& var)
	{
		if (this != &var)
		{
			this->m_variant = var.m_variant;
		}
		return *this;
	}

	template <typename T>
	void toValue(T& t)
	{
		toValue(t, m_variant);
	}

private:
	template <typename T>
	void toValue(T& t, PVariant& var)
	{
		if (var.type() == typeid(T))
		{
			t = boost::get<T>(var);
		}
	}

private:
	PVariant m_variant;
};

使用起来会很方便。

CVariant v1 = 1;
CVariant v2 = "123";
CVariant v3 = 12.3;	

在此处使用的构造函数的重载。

2.其它自定义类型转换为自定义类型