独家解读：简单又强大的配置文件 Config 读写类

一、引言

在项目过程中，难免会需要一个方便的配置文件读写类，它可以像游戏的存档文件一样，记录着我们当前项目的配置信息，以至于方便我们每次初始化运行的时候可以从这个配置文件读取上一次的配置信息，当然也可以在程序运行过程中记录用户的配置设置信息。

我们理想中的这个配置文件读写类，它要有以下这些方法：

1. 支持读入一个指定配置文件的能力

2. 支持随时加入一个配置项的能力

3. 足够强大，能够写入各种数据结构的配置信息

满足以上条件的配置文件读写类才是我们想要的。这篇博客显然不是一步一步介绍如何写出这样一个类的文章（这不是一件容易的事情，即使写出来也会千疮百孔），而是一篇在网上已有的流传久远的一个短小精悍的配置文件 Config 读写类的基础上的解读分析文章。

我找到的这个短小精悍的配置文件 Config 读写类是来自于这篇博客：
C++编写Config类读取配置文件

这篇博客的作者仅仅粘贴出了这个 Config 类的代码以及简简单单的几行测试代码，对于大多数新手来说并不友好，因此我特意在阅读了相关代码并且自行建立测试项目进行了测试之后，萌发了想要写一篇博客来好好解读这个 Config 类的原理和用法的想法。

由于不喜欢在博客里面大篇幅的粘贴代码，因此想要获取到这个配置文件 Config 读写类的同学可以在我的 GitHub 上阅读这个类（也就简简单单三个文件：一个 Config.h，另一个是 Config.cpp，testconfig.cpp 则是用来测试的文件而已）:
wangying2016/Config

那么接下来，就让我们一步一步分析这个配置文件 Config 读写类的设计与实现吧！

二、Config 设计之：数据结构

要想了解一个类的设计与实现，最好的方法就是去了解它的设计目标，即需要满足的需求。

这里我们需要了解的就是，一个配置文件的内容究竟是什么样子的：

config contents

由上图可知，我们的一个配置文件，是由两部分组成的：

1. 注释内容：在示例文件中是由 # 来单行注释表示的，用来解释一些必要内容

2. 配置项内容：配置内容其实就是一个一个的键值对的记录，左侧是 key 值，比如这里的 name 值，右侧是 value 值，对应这里的 wangying。而在键值对中间，间插了一个符号 =（当然可以自定义的）来分割 key 值和 value 值。

可知，其实配置文件的内容是非常简单明了的。接下来，我们则需要将这种看似简单的文件结构抽象成我们熟悉的程序设计领域的数据结构。

如果你学过主流编程语言的话，这里的键值对应该会让你想起那么几个词：
map、hash、dictionary 等等
在程序员的世界里，键值对其实就是我们的映射。比如在 C++ 里，我们要存储这样的数据就使用 std::map 即可。

也就是说，我们的 Config 类中，需要有一个最基本最基本的存储配置文件键值对信息的 std::map 成员，这个成员用来将配置文件中的每个 key 值和其对应的 value 值记录下来。

那么另外一个问题也就来了，我们的 std::map 究竟应该是什么类型的呢？

哈哈，这个问题其实非常简单，因为我们的键值对信息都是要读出写入到文件的，那么 std::map 不论是 key 值还是 value 值都将会是字符串类型，即 C++ STL 的 std::string （Config 类不支持中文编码）类即可。

那么有人就会问了，如果 value 值只是一个简简单单的 std::string 类的话，我想要存储一个非常复杂的数据结构怎么办，比如一个 phone key 值，对应了一个电话号码列表呢？

这个问题其实也非常简单，这里的 std::map 成员只是 Config 类中的最基本最基本存储到文件里的字符串键值对记录，而 Config 为了支持用户存储多种复杂的 value 值，还提供了模板支持。因此，这里只需要你提供的 value 值的结构可以被转化为 std::string 类型，就可以使用 Config 类来存储你的数据结构了。

因此，让我们看看 Config 类的代码：

std::string m_Delimiter;  //!< separator between key and value  
std::string m_Comment;    //!< separator between value and comments  
std::map<std::string, std::string> m_Contents;  //!< extracted keys and values

这三个内部的属性， m_Delimiter 是我们之前提到的 key 值和 value 值的分隔符 = 的设置，m_Comment 是我们之前提到的注释内容开头 # 字符的设置，m_Contents 就是我们上面讨论的 std::map 对象，并且以 key 值和 value 值均为 std::string 类型存储。

此外，我们在 Config 类中看到的那么多的模板函数，其归根结底想要实现的，就是支持用户自定义的 value 数据结构的读取和写入：

//!<Search for key and read value or optional default value, call as read<T>  
template<class T> T Read(const std::string& in_key) const;  
// Modify keys and values  
template<class T> void Add(const std::string& in_key, const T& in_value);

这里截取了两个重要的函数，一个用来读取 key 值对应的 value 值，一个用来添加一个键值对。可以看到，这里的 key 值永远都是一个 std::string 类型的对象，而相应的 value 值则是模板定义的类型，支持用户自定义传入任何的可以转成 std::string 类型的数据结构。

三、Config 设计之：暴露方法

接下来让我们想想这样一个问题，在我们看到了配置文件的内容之后，并且将其抽象成了 std::map 的数据结构，之后我们需要做的，就是给类的调用者暴露方法的方法即可。

那么应该有哪些方法呢：

1. 一个可以跟某个具体的配置文件绑定起来的构造函数

2. 获取指定 key 值的 value 值

3. 加入一对键值对

4. 修改指定 key 值的 value 值

5. 删除一对键值对

暂时就想到了这些比较重要的，那么 Config 类中提供了这些方法了吗？

哈哈，提供了，让我们一个一个来看：

1. 一个可以跟某个具体的配置文件绑定起来的构造函数

Config::Config(string filename, string delimiter, string comment)
    : m_Delimiter(delimiter), m_Comment(comment)
{
    // Construct a Config, getting keys and values from given file  
    std::ifstream in(filename.c_str());
    if (!in) throw File_not_found(filename);
    in >> (*this);
}

作者使用 std::ifstream 打开了一个本地文件，注意，调用这个方法之前必须保证该文件存在。我们要注意到作者调用了 in >> (*this)，调用了本类的 operator>> 重载函数，用来读取文件内容（此函数过于冗长，可以自行查看源码）并将其存储到 std::map

//!<Search for key and read value or optional default value, call as read<T>  
template<class T> T Read(const std::string& in_key) const;  
template<class T> T Read(const std::string& in_key, const T& in_value) const;
template<class T> bool ReadInto(T& out_var, const std::string& in_key) const;

这三个都是模板函数，主要是用来获取用户自定义数据结构的 value 值。需要注意的是，这三个函数的用法，第一个是返回 value 值；第二个是可以将 value 值在参数中返回；第三个直接将 value 值写入到传入的 var 对象中。

3. 加入一对键值对
4. 修改指定 key 值的 value 值
作者直接使用了一个函数即完成了第 3 点和第 4 点的工作：

template<class T>
void Config::Add(const std::string& in_key, const T& value)
{
    // Add a key with given value  
    std::string v = T_as_string(value);
    std::string key = in_key;
    Trim(key);
    Trim(v);
    m_Contents[key] = v;
    return;
}

这里使用了 C++ 的 std::map 的特性，如果 key 值在 std::map 中存在，则更新 value 值，否则就新增一对键值对。需要注意的是，这里调用了这行代码：

std::string v = T_as_string(value);

其中 T_as_string 函数将用户传入的自定义模板类转化为 std::string 类型进行存储，而该方法的实现如下：

/* static */
template<class T>
std::string Config::T_as_string(const T& t)
{
    // Convert from a T to a string  
    // Type T must support << operator  
    std::ostringstream ost;
    ost << t;
    return ost.str();
}

这个类直接调用了用户自定义模板类的 operator<< 重载操作符函数，也就是说，只要用户自定义数据结构自定义重载了 operator<< 操作符函数，就可以用 Config 类来进行 value 值的读写操作了。

5. 删除一对键值对

void Config::Remove(const string& key)
{
    // Remove key and its value  
    m_Contents.erase(m_Contents.find(key));
    return;
}

幸而有 C++ STL 强大的功能，删除一对键值对就是这么简单。

6. 另外的一些方法
作者为了方便用户使用，还提供了诸如查询文件是否存在、键值是否存在、读入文件、设置获取键值分隔符、设置获取注释标识符等等方法。都是比较简单并且易用的，感兴趣的同学可以自行查看源码。

四、Config 的使用 Demo

这里，我自行编写了一个 Demo 来测试 Config 类的功能：

#include <iostream>
#include <cstdlib>
#include <string>
#include <fstream>
#include "Config.h"

int main()
{
    // 打开一个写文件流指向 config.ini 文件
    std::string strConfigFileName("config.ini");
    std::ofstream out(strConfigFileName);
    // 初始化写入注释
    out << "# test for config read and write\n";
    // 写入一对配置记录： name = wangying
    out << "name = wangying\n";
    out.close();

    // 初始化 Config 类
    Config config(strConfigFileName);

    // 读取键值
    std::string strKey = "name";
    std::string strValue;
    strValue = config.Read<std::string>(strKey);
    std::cout << "Read Key " << strKey << "'s Value is " 
         << strValue << std::endl;

    // 写入新键值对
    std::string strNewKey = "age";
    std::string strNewValue = "23";
    config.Add<std::string>(strNewKey, strNewValue);

    // 将 Config 类的修改写入文件
    out.open(strConfigFileName, std::ios::app);
    if (out.is_open()) {
        // 利用 Config 类的 << 重载运算符
        out << config;
        std::cout << "Write config content success!" << std::endl;
    }
    out.close();

    system("pause");
    return 0;
}

幸而有强大的 Config 类，让我操作配置文件变成了一件这么简单的事情！

output

config generate

然而这里需要注意的是，我们在使用 Config 类进行了 Add() 操作之后，我们仅仅只是在 Config 类中操作了 std::map 类型的 m_Contens 对象内容而已，我们还需要将其写入到文件中去，因此这里我最后调用了写文件流进行写入操作，注意这行代码：

// 利用 Config 类的 << 重载运算符
out << config;

这里隐含调用了 Config 类的 operator<< 重载运算符：

std::ostream& operator<<(std::ostream& os, const Config& cf)
{
    // Save a Config to os  
    for (Config::mapci p = cf.m_Contents.begin();
        p != cf.m_Contents.end();
        ++p)
    {
        os << p->first << " " << cf.m_Delimiter << " ";
        os << p->second << std::endl;
    }
    return os;
}