Cocos数据篇[3.4](5)——CSV文件解析

【唠叨】

    在一个游戏中，通常会有很多怪物、关卡、技能等数据，这些数据不可能在代码里写死，一般都会使用配置文件保存，使用时再加载到内存。

    CSV文件编辑起来十分简单，所以常常用来配置游戏的数据信息。

    本文要介绍的是：如何读取CSV文件格式的数据。

【扩展阅读】

    http://baike.baidu.com/subview/468993/5926031.htm （CSV百度百科）

    http://blog.csdn.net/stevenkylelee/article/details/38309147 （CSV文件格式解析器的实现）

    http://www.benmutou.com/archives/1634 （Lua 读取Csv文件）

【CSV简介】

    这位大牛的博文写得很好：

        http://blog.csdn.net/stevenkylelee/article/details/38309147 

1、什么是CSV？

    CSV，即逗号分隔值（Comma-Separated Values）。有时也称为字符分隔值，因为分隔字符也可以不是逗号，可以是分号;），其文件以纯文本形式存储表格数据（数字和文本）。

    这种文件格式经常用来作为不同程序之间的数据交互的格式。

    CSV格式数据的结构类似表格，不同的记录占用一行，一行中的字段用“，”（逗号）分隔。

    例如：

2、编辑CSV文件

    在MacOS系统上   ，可以使用 Numbers 来创建表格文件，然后再保存为csv格式的文件即可。

    在Windows系统上，可以使用 Excel 来编辑csv文件。

    当然你也可以使用其他csv编辑软件。

    （1）使用Numbers软件，可以很方便的编辑表格数据。

    （2）保存为csv格式文件。

    （3）打开导出的csv文件，可以发现每条数据占一行，并且每一行的数据用逗号分割。

3、CSV格式规则

    （1）开头是不留空  ，以行为单位。

    （2）每条记录占一行，以逗号为分隔符。列为空也要表达其存在。

    （3）可含或不含列名，如果含列名则居文件第一行。

    （4）一行数据不跨行，无空行。

    （5）字段中包含有逗号符，该字段必须用双引号括起来。

    （6）字段中包含有换行符，该字段必须用双引号括起来。

    （7）字段前后包含有空格，该字段必须用双引号括起来。（ a b c ==> "a b c"）

    （8）字段中的双引号，用两个双引号表示。（ 我说："abc"。 ==> 我说：""abc""。 ）

    （9）字段中如果有双引号，该字段必须用双引号括起来。（ 我说："abc"。 ==> "我说：""abc""。" ）

    PS：中文的逗号、双引号不需要用双引号包起来。

    可以看看如下的例子：

4、为什么使用CSV？

    （1）CSV文件格式占用空间比较小，是文本文件。

    （2）CSV文件可以用记事本打开，编辑修改方便。同时也可以用Excel打开。

    （3）游戏项目中，策划通常喜欢用 Excel 做数值和配置。 Excel可以直接另存为CSV文件。

    （4）配置也可以用xml。Excel同样可以导出xml文件格式。xml不错，但C++的标准库没有xml的读取方法。通常C++项目读xml需要依赖第三方库。例如：TinyXml之类的。

【CSV解析】

    这里介绍一下C++版本的CSV解析。

    注意：CSV文件的编码格式，如在手游中一般使用 UTF-8 编码格式。

    PS：笨木头写过Lua版读取CSV数据。参见：http://www.benmutou.com/archives/1634 

    以下CSV解析的代码，是在这篇博文的基础上，进行的修改。

        > 参考代码： http://blog.csdn.net/stevenkylelee/article/details/38309147 

    使用C/C++标准库编写的，不依赖Cocos2d-x里面的任何一个类或函数。

    这样的好处是，增强了CSV解析的通用性，即使在编写控制台应用程序，也可以正常使用。

1、CSVParser.h

    （1）命名空间：CSVParser

    （2）Row类   ：一行的数据记录。已重载 [] 运算符，可以通过“键值对”方式获取数据值。

    （3）Csv类    ：解析csv文件。已重载 [] 运算符，可以像数组一样获取数据值。

//
#pragma once

#include 
#include 
using namespace  std;


namespace CSVParser {

    // 每一行的记录
    class Row
    {
    public:
        Row() { }
        ~Row() { }

        void push_back(const string& value) { m_values.push_back(value); }
        void setHeader(const vector* header) { m_header = header; }

    public:

        // 每行数据有多少字段
        unsigned int size() const { return m_values.size(); }
        
        // 运算符 [] 重载
        string& operator[](unsigned int key)
        {
            if (key < size()) return m_values[key];
            throw "can‘t return this value (doesn‘t exist)";
        }
        
        // 运算符 [] 重载
        string& operator[](const string& key)
        {
            vector::const_iterator it;
            int pos = 0;
            for (it = (*m_header).begin(); it != (*m_header).end(); it++) {
                if (key == *it) return m_values[pos];
                pos++;
            }
            throw "can‘t return this value (doesn‘t exist)";
        }

    private:
        const vector* m_header;
        vector m_values;
    };


    class Csv
    { 
    public:
        Csv(const string& filename);
        ~Csv();
        
        // 解析csv文件
        void Parse(const string& filename);
        
        // 错误信息
        const string& getErrorInfo() const { return m_strErrorInfo; }
        
        // 获取列头字段
        vector getHeader() const { return m_header; }
        // 获取总行数
        unsigned int getRowCount() const { return m_content.size(); }
        // 获取总列数
        unsigned int getColumnCount() const { return m_header.size(); }
        // 运算符 [] 重载
        Row& operator[](unsigned int key);

    private:
        // 读取整个文件的数据
        void Load(const string& filename, string& Data);
        // 设置列头字段，用于[]运算符，以键值对方式获取数据值
        void setHeader();

    private :
        // 原始表格数据
        vector m_content;   // 所有行的数据（包含列头）
        vector m_header; // 列头字段
        // 错误信息
        string m_strErrorInfo;
    };


}
//

2、CSVParser.cpp

    类的实现代码如下：

//
#include "CSVParser.h"


namespace CSVParser {

    Csv::Csv(const string& filename)
    {
        Parse(filename);
    }

    Csv::~Csv()
    {

    }


    void Csv::Load(const string& filename, string& Data)
    {
        // 读取文件数据
        FILE* pFile = fopen(filename.c_str(), "rb");
        if (!pFile) {
            return;
        }
        
        fseek(pFile, 0, SEEK_END);
        long len = ftell(pFile);
        
        char* pBuffer = new char[len + 1];
        
        fseek(pFile, 0, SEEK_SET);
        fread(pBuffer, 1, len, pFile);
        fclose(pFile);
        
        pBuffer[len] = 0;
        Data.assign(pBuffer, len);
        
        delete[] pBuffer;
    }


    void Csv::Parse(const string& filename)
    {
        // 清除之前的数据
        m_content.clear();
        m_strErrorInfo.clear();
        
        string text;
        Load(filename, text);
        
        if (text.size() == 0) {
            return;
        }
        
        // 定义状态
        enum StateType {
            NewFieldStart,      // 新字段开始
            NonQuotesField,     // 非引号字段
            QuotesField,        // 引号字段
            FieldSeparator,     // 字段分隔
            QuoteInQuotesField, // 引号字段中的引号
            RowSeparator,       // 行分隔符字符1，回车
            Error,              // 语法错误
        };
        
        Row Fields = Row();
        string strField;
        
        // 设置初始状态
        StateType State = NewFieldStart;
        
        for (int i = 0, size = text.size(); i < size; ++i) {
            const char& ch = text[i];
            
            switch (State) {
                case NewFieldStart: { // 新字段开始
                    if (ch == ‘"‘) {
                        State = QuotesField;
                    }
                    else if (ch == ‘,‘) {
                        Fields.push_back("");
                        State = FieldSeparator;
                    }
                    else if (ch == ‘\r‘ || ch == ‘\n‘) {
                        m_strErrorInfo = "语法错误：有空行";
                        State = Error;
                    }
                    else {
                        strField.push_back(ch);
                        State = NonQuotesField;
                    }
                }
                break;
                    
                case NonQuotesField: { // 非引号字段
                    if (ch == ‘,‘) {
                        Fields.push_back(strField);
                        strField.clear();
                        State = FieldSeparator;
                    }
                    else if (ch == ‘\r‘) {
                        Fields.push_back(strField);
                        State = RowSeparator;
                    }
                    else {
                        strField.push_back(ch);
                    }
                }
                break;
                    
                case QuotesField: { // 引号字段
                    if (ch == ‘"‘) {
                        State = QuoteInQuotesField;
                    }
                    else {
                        strField.push_back(ch);
                    }
                }
                break;
                    
                case FieldSeparator: { // 字段分隔
                    if (ch == ‘,‘) {
                        Fields.push_back("");
                    }
                    else if (ch == ‘"‘) {
                        strField.clear();
                        State = QuotesField;
                    }
                    else if (ch == ‘\r‘) {
                        Fields.push_back("");
                        State = RowSeparator;
                    }
                    else {
                        strField.push_back(ch);
                        State = NonQuotesField;
                    }
                }
                break;
                    
                case QuoteInQuotesField: { // 引号字段中的引号
                    if (ch == ‘,‘) {
                        // 引号字段闭合
                        Fields.push_back(strField);
                        strField.clear();
                        State = FieldSeparator;
                    }
                    else if (ch == ‘\r‘) {
                        // 引号字段闭合
                        Fields.push_back(strField);
                        State = RowSeparator;
                    }
                    else if (ch == ‘"‘) {
                        // 转义
                        strField.push_back(ch);
                        State = QuotesField;
                    }
                    else {
                        m_strErrorInfo = "语法错误： 转义字符 \" 不能完成转义 或 引号字段结尾引号没有紧贴字段分隔符";
                        State = Error;
                    }
                }
                break;
                    
                case RowSeparator: { // 行分隔符字符1，回车
                    if (ch == ‘\n‘) {
                        m_content.push_back(Fields);
                        Fields = Row(); // Fields.clear();
                        strField.clear();
                        State = NewFieldStart;
                    }
                    else {
                        m_strErrorInfo = "语法错误： 行分隔用了回车 \\r。但未使用回车换行 \\r\\n ";
                        State = Error;
                    }
                }
                break;
                    
                case Error: { // 语法错误
                    return;
                }
                break;

                default: break;
            }
        }
        // end for
        
        switch (State) {
            case NewFieldStart: {
                // Excel导出的CSV每行都以/r/n结尾。包括最后一行
            }
            break;
            
            case NonQuotesField: {
                Fields.push_back(strField);
                m_content.push_back(Fields);
            }
            break;
                
            case QuotesField: {
                m_strErrorInfo = "语法错误： 引号字段未闭合";
            }
            break;
                
            case FieldSeparator: {
                Fields.push_back("");
                m_content.push_back(Fields);
            }
            break;
                
            case QuoteInQuotesField: {
                Fields.push_back(strField);
                m_content.push_back(Fields);
            }
            break;
                
            case RowSeparator: {
                
            }
            break;
                
            case Error: {
                
            }
            break;
                
            default: break;
        }
        
        setHeader();
    }


    void Csv::setHeader()
    {
        m_header.clear();
        for (int i = 0; i < m_content[0].size(); i++) {
            m_header.push_back(m_content[0][i]);
        }
        for (int i = 0; i < m_content.size(); i++) {
            m_content[i].setHeader(&m_header);
        }
    }


    Row& Csv::operator[](unsigned int key)
    {
        if (key < m_content.size()) return m_content[key];
        throw "can‘t return this row (doesn‘t exist)";
    }

}
//

3、使用方法

    （1）csv文件数据

        在MacOS系统上，使用 Numbers 编辑的表格，并导出为csv格式。

    （2）解析csv文件，获取数据

//
    #include 
    #include 
    using namespace std;


    //[1] 引入头文件、命名空间
    #include "CSVParser.h"
    using namespace CSVParser;


    int main()
    {
    //[2] csv文件完整路径
        string path = "/soft/cocos2d-x-3.4/projects/Demo34/Resources/testCSV.csv";

    //[3] 解析csv文件
        Csv csv = Csv(path.c_str());

    //[4] 获取总行数（包含列头）、总列数
        printf("总共有 %d 行\n", csv.getRowCount());
        printf("总共有 %d 列\n", csv.getColumnCount());
        
    //[5] 获取所有数据（第0行为列头字段）
        // csv.getRowCount() : 数据总行数（包含列头）
        for (int i =0; i < csv.getRowCount(); i++) {
            // csv[i].size() : 每条数据有多少字段
            for (int j = 0; j < csv[i].size(); j++) {
                printf("%s,", csv[i][j].c_str());
            }
            puts("");
        }
        
    //[6] 也可以根据列头名称，获取数据
        printf("%s\n", csv[2]["备注"].c_str());
        
    //[7] 获取某一行数据
        Row row = csv[4];
        printf("%s\n", row["姓名"].c_str());

        return 0;
    }
//

    （3）运行结果

    【源码下载】：http://down.51cto.com/data/1983838 

本文出自 “夏天的风” 博客，请务必保留此出处http://shahdza.blog.51cto.com/2410787/1614802

Cocos数据篇[3.4](5) ——CSV文件解析