统一的类成员初始化语法与std：：initializer_list＜T＞

//C++ 98/03类成员变量是数组时的初始化语法
class A
{
public:
	A()
	{
		arr[0] = 2;
		arr[1] = 0;
		arr[2] = 1;
		arr[3] = 9;
	}
public:
	int arr[4];
};

//在 C++11中可以使用大括号语法初始化数组类型的成员变量
class A
{
public:
	A() :arr{ 2,0,1,9 }
	{

	}
public:
	int arr[4];
};

//在C++98/03标准中，对类的成员必须使用static const修饰，
//而且类型必须是整型（包括bool、char、int、long等），这样才能使用这种初始化语法
class A
{
public:
	//T的类型必须是整形，切必须使用static const修饰
	static const T t = _abs64;
};

//在C++11标准中就没有这种限制了，
//我们可以使用花括号（即{}）对任意类型的变量进行初始化，而且不用是static类型
class A
{
public:
	bool ma{ true };
	int mb{ 2019 };
	std::string mc{ "helloworld" };
};

综上所述，在C++11标准中，无论是局部变量还是类变量，使用花括号（{}）初始化的语法被统一起来，写法也变得简洁.

        那么这种语法是如何实现的呢？如何在自定义类中也支持这种花括号呢？这就需要用到C++11新引入的对象std：：initializer_list<T>了。它是一个模板对象，接收一个自定义参数类型 T，T既可以是基础数据类型（如编译器内置的 bool、char、int等），也可以是自定义的复杂数据类型。为了使用 std：：initializer_list<T>，需要包含头文件，下面是一个例子：

#include<iostream >
#include <initializer_list>
#include<vector>
class A {
public:
	A(std::initializer_list<int> integers)
	{
		m_vecIntegers.insert(m_vecIntegers.end(),integers.begin(), integers.end());
	}
	~A()
	{}
	void append(std::initializer_list<int> integers)
	{
		m_vecIntegers.insert(m_vecIntegers.end(), integers.begin(), integers.end());
	}
		
	void print()
	{
		size_t size = m_vecIntegers.size(); 
		for (size_t i = 0; i < size; ++i)
			std::cout << m_vecIntegers[i] << std::endl;
	}
		
private:
	std::vector<int> m_vecIntegers;
};
int main(){
	A a{1,2,3};
	a.print();
	std::cout << "After appending..." << std::endl;
	a.append({ 4,5,6 });
	a.print();
	return 0;
}

json::array数据解析实现

#include<iostream>
#include<string>
#include<initializer_list>
#include<vector>

enum class jsonType
{
	jsonTypeNull,
	jsonTypeInt,
	jsonTypeLong,
	jsonTypeDouble,
	jsonTypeBool,
	jsonTypeString,
	jsonTypeArray,
	jsonTypeObject
};

struct jsonNode
{
	jsonNode(const char* key, const char* value):m_type(jsonType::jsonTypeString),m_key(key),m_value(value)
	{
		std::cout << "jsonNode contructorl call." << std::endl;
	}

	jsonNode(const char* key, double value):m_type(jsonType::jsonTypeDouble),m_key(key),m_value(std::to_string(value))
	{
		std::cout << "jsonNode contructorl2 call." << std::endl;
	}
	jsonType m_type;
	std::string m_key;
	//始终使用string类型保存值，避免浮点类型因为精度问题而显示不同的结果
	std::string m_value;
};

class json
{
public:
	static json& array(std::initializer_list<jsonNode> nodes)
	{
		m_json.m_nodes.clear();
		m_json.m_nodes.insert(m_json.m_nodes.end(), nodes.begin(), nodes.end());

		std::cout << "json::array() called." << std::endl;
		return m_json;
	}
	json()
	{

	}
	~json()
	{

	}

	std::string toString()
	{
		size_t size = m_nodes.size();
		for (size_t i=0;i< size;i++)
		{
			switch (m_nodes[i].m_type)
			{
			case jsonType::jsonTypeDouble:
				break;
			default:
				break;
			}
		}
	}

private:
	std::vector<jsonNode> m_nodes;
	static json m_json;
};

int main()
{
	json array_not_object = json::array({ {"currency","USD"},{"value",42.99} });
	return 0;
}