C++更快的字符串解析

如果我正确理解您的格式，每行都以数字开头，后面跟着冒号分隔的对。每行上的第一对具有特殊含义，由std::string和size_t组成，而所有其他对由索引（忽略）和double组成。根本没有理由使用Boost：直接使用IOStreams：

std::streamsize    max(std::numeric_limits<std::streamsize>::max());
std::string        line;
std::istringstream in;
for (std::size_t i(0); i < 1000 && std::getline(train, line); ++i) {
    double label;
    size_t query;
    in.clear();
    in.str(line)
    if ((in >> label).ignore(max, ':') >> query) {
         boost::numeric::ublas::vector<double> features;
         while (in.ignore(max, ':') >> feature) {
              features.push_back(feature);
         }
         assert(features.size() == 136);
         m_train.push_back(query, features, label);
    }
}

请注意，此代码会仔细检查读取是否确实成功。您的代码提前检查了读取是否成功，但这并不可靠。例如，如果你的最后一行只是由一个虚假的空间组成，你的assert()会触发，这几乎不是你想要的。

多次截断字符串需要内存分配和释放。您可以使用好的旧strtod和char指针来避免拆分字符串。这将在一定程度上解决30%的字符串标记化支出。至于将刺痛转化为双打的40%，这可能无法得到显著改善。

如果你想找到一个快速、肮脏、丑陋但可能是最快的纯C解决方案，试试这个。该测试在E8300 2.83 GHz CPU上完成，耗时约35秒。假设所有字符串都具有完全相同的格式。

#include "stdio.h"
void main ()
{
    const char* test_str = "2 qid:1 1:3 2:3 3:0 4:0 5:3 6:1 7:1 8:0 9:0 10:1 11:156 12:4 13:0 14:7 15:167 16:6.931275 17:22.076928 18:19.673353 19:22.255383 20:6.926551 21:3 22:3 23:0 24:0 25:6 26:1 27:1 28:0 29:0 30:2 31:1 32:1 33:0 34:0 35:2 36:1 37:1 38:0 39:0 40:2 41:0 42:0 43:0 44:0 45:0 46:0.019231 47:0.75000 48:0 49:0 50:0.035928 51:0.00641 52:0.25000 53:0 54:0 55:0.011976 56:0.00641 57:0.25000 58:0 59:0 60:0.011976 61:0.00641 62:0.25000 63:0 64:0 65:0.011976 66:0 67:0 68:0 69:0 70:0 71:6.931275 72:22.076928 73:0 74:0 75:13.853103 76:1.152128 77:5.99246 78:0 79:0 80:2.297197 81:3.078917 82:8.517343 83:0 84:0 85:6.156595 86:2.310425 87:7.358976 88:0 89:0 90:4.617701 91:0.694726 92:1.084169 93:0 94:0 95:2.78795 96:1 97:1 98:0 99:0 100:1 101:1 102:1 103:0 104:0 105:1 106:12.941469 107:20.59276 108:0 109:0 110:16.766961 111:-18.567793 112:-7.760072 113:-20.838749 114:-25.436074 115:-14.518523 116:-21.710022 117:-21.339609 118:-24.497864 119:-27.690319 120:-20.203779 121:-15.449379 122:-4.474452 123:-23.634899 124:-28.119826 125:-13.581932 126:3 127:62 128:11089534 129:2 130:116 131:64034 132:13 133:3 134:0 135:0 136:0";
    const char* format = "%lf qid:%lf 1:%lf 2:%lf 3:%lf 4:%lf 5:%lf 6:%lf 7:%lf 8:%lf 9:%lf 10:%lf 11:%lf 12:%lf 13:%lf 14:%lf 15:%lf 16:%lf 17:%lf 18:%lf 19:%lf 20:%lf 21:%lf 22:%lf 23:%lf 24:%lf 25:%lf 26:%lf 27:%lf 28:%lf 29:%lf 30:%lf 31:%lf 32:%lf 33:%lf 34:%lf 35:%lf 36:%lf 37:%lf 38:%lf 39:%lf 40:%lf 41:%lf 42:%lf 43:%lf 44:%lf 45:%lf 46:%lf 47:%lf 48:%lf 49:%lf 50:%lf 51:%lf 52:%lf 53:%lf 54:%lf 55:%lf 56:%lf 57:%lf 58:%lf 59:%lf 60:%lf 61:%lf 62:%lf 63:%lf 64:%lf 65:%lf 66:%lf 67:%lf 68:%lf 69:%lf 70:%lf 71:%lf 72:%lf 73:%lf 74:%lf 75:%lf 76:%lf 77:%lf 78:%lf 79:%lf 80:%lf 81:%lf 82:%lf 83:%lf 84:%lf 85:%lf 86:%lf 87:%lf 88:%lf 89:%lf 90:%lf 91:%lf 92:%lf 93:%lf 94:%lf 95:%lf 96:%lf 97:%lf 98:%lf 99:%lf 100:%lf 101:%lf 102:%lf 103:%lf 104:%lf 105:%lf 106:%lf 107:%lf 108:%lf 109:%lf 110:%lf 111:%lf 112:%lf 113:%lf 114:%lf 115:%lf 116:%lf 117:%lf 118:%lf 119:%lf 120:%lf 121:%lf 122:%lf 123:%lf 124:%lf 125:%lf 126:%lf 127:%lf 128:%lf 129:%lf 130:%lf 131:%lf 132:%lf 133:%lf 134:%lf 135:%lf 136:%lf";
    double data[138];
    for (int i = 0; i < 500000; i++)
    {
        sscanf(test_str, format, 
            data+0, data+1, data+2, data+3, data+4, data+5, 
            data+6, data+7, data+8, data+9, data+10, data+11, 
            data+12, data+13, data+14, data+15, data+16, data+17, 
            data+18, data+19, data+20, data+21, data+22, data+23, 
            data+24, data+25, data+26, data+27, data+28, data+29, 
            data+30, data+31, data+32, data+33, data+34, data+35, 
            data+36, data+37, data+38, data+39, data+40, data+41, 
            data+42, data+43, data+44, data+45, data+46, data+47, 
            data+48, data+49, data+50, data+51, data+52, data+53, 
            data+54, data+55, data+56, data+57, data+58, data+59, 
            data+60, data+61, data+62, data+63, data+64, data+65, 
            data+66, data+67, data+68, data+69, data+70, data+71, 
            data+72, data+73, data+74, data+75, data+76, data+77, 
            data+78, data+79, data+80, data+81, data+82, data+83, 
            data+84, data+85, data+86, data+87, data+88, data+89, 
            data+90, data+91, data+92, data+93, data+94, data+95, 
            data+96, data+97, data+98, data+99, data+100, data+101, 
            data+102, data+103, data+104, data+105, data+106, data+107, 
            data+108, data+109, data+110, data+111, data+112, data+113, 
            data+114, data+115, data+116, data+117, data+118, data+119, 
            data+120, data+121, data+122, data+123, data+124, data+125, 
            data+126, data+127, data+128, data+129, data+130, data+131, 
            data+132, data+133, data+134, data+135, data+136, data+137);
    }
}

C99有vsscanf，这会使它看起来更好。然后，根据数据集格式，可以在循环之前动态预生成一次格式字符串。请确保检查此样本中sscanf的返回值是否正好为138。

编辑：Dietmar Kühl的解决方案看起来很干净，而且如果速度比一个sscanf慢的话，肯定不会太慢。最好只将上面的代码用作基准参考。

没有一些实验很难说，但。。。

我会先放弃boost::split。它正在制作std::vector<std::string>，这反过来又涉及到许多动态分配和复制。你可能想做的是写一些在++前进到下一个令牌的字符串上的迭代器，以及CCD_ 10返回一对定义当前令牌的迭代器。这样可以避免中间数据结构。

然后，您可以在这对上定义一个<<运算符，类似于：

std::ostream&
operator<<( std::ostream& dest, TextRange const& token )
{
    std::copy( token.begin(), token.end(),
               std::ostream_iterator<char>( dest ) );
    return dest;
}

减少CCD_ 12使用的时间将更加困难。基本上，boost::lexical_cast使用<<将源插入一个std::stringstream和>>来提取它。你可以写一些东西类似，但使用您自己的streambuf，基于迭代器对（非常简单），因此给定迭代器对，1）您不必使用<<，因为这对迭代器变成了istream，并且2）完全避免产生任何中间CCD_ 18。（你知道不希望重新实现std::istream中的转换例程。）