c++ - 查找文件名中的数字并与其他数字交叉引用

Question

首先，我将快速描述我这样做的动机和实际问题:
我不断地处理大量文件，更具体地说，我发现自己必须根据以下规则重命名它们:
它们可能都包含单词和数字，但只有一组数字是递增的，而不是“恒定的”。我需要提取那些并且只提取那些数字并相应地重命名文件。例如:

Foo_1_Bar_2015.jpg
Foo_2_Bar_2015.jpg
Foo_03_Bar_2015.jpg
Foo_4_Bar_2015.jpg

将重命名:

1.jpg
2.jpg
3.jpg or 03.jpg (The leading zero can stay or go)
4.jpg

因此，我们从一个 vector 开始，该 vector 包含指定目录中所有文件名的 std::wstring 对象。我敦促您停止阅读 3 分钟，并在我继续我的尝试和问题之前考虑如何解决这个问题。我不希望我的想法将您推向一个或另一个方向，而且我一直发现新鲜的想法是最好的。

现在，这里有两种我能想到的方法:

1) 旧式 C 字符串操作和比较:
在我看来，这需要解析每个文件名并记住每个数字序列的位置和长度。对于每个文件，这很容易存储在 vector 或类似的东西中。这很好用(基本上使用增加偏移量的字符串搜索):

while((offset = filename_.find_first_of(L"0123456789", offset)) != filename.npos)
{
    size = filename.find_first_not_of(L"0123456789", offset) - offset;
    digit_locations_vec.emplace_back(offset, size);
    offset += size;
}

这之后我得到的是文件名中所有数字的(位置，大小)对 vector ，是否为常量(通过使用动机中的定义)。
在此之后，困惑接踵而至，因为您需要交叉引用字符串并找出哪些数字是需要提取的数字。这将随着未提及的文件数量(往往很大)乘以每个字符串中的数字序列数量而呈指数增长。此外，可读性、可维护性或优雅性都不是很好。不行。

2) 正则表达式

如果有正则表达式的用途，那就是这个。从第一个文件名创建一个正则表达式对象，并尝试将其与下一个匹配。成功？即时提取所需数量的能力。失败？将有问题的文件名添加为新的正则表达式对象，并尝试匹配两个现有的正则表达式。冲洗并重复。正则表达式看起来像这样:

Foo_(\d+)_Bar_(\d+).jpg

或者分别为每个数字序列创建一个正则表达式:

Foo_(\d+)_Bar_2015.jpg
Foo_1_Bar_(\d+).jpg

剩下的就是蛋糕了。继续匹配，在最好的情况下，它可能只需要一次通过!问题是……

我需要知道的:

1) 你能想出任何其他更好的方法来实现这一目标吗？这几天我一直在用头撞墙。
2) 尽管在第一种方法中字符串操作和 vector 构造\破坏的成本可能很高，但与正则表达式对象的成本相比，它可能相形见绌。第二种方法，最坏的情况:与文件一样多的正则表达式对象。如果有数千个文件，这会是灾难性的吗？
3) 第二种方法可以针对以下两种可能性之一进行调整:很少有 std::regex 对象构造，很多 regex_match 调用或相反。构建 regex 对象还是尝试用它匹配字符串哪个更昂贵？

Answer 1

对我来说(gcc4.6.2 32 位优化 O3)，手动字符串操作比正则表达式快大约 2 倍。不值得付出代价。

示例可运行的完整代码(与 boost_system 和 boost_regex 的链接，或者如果编译器中已经有正则表达式则更改 include):

#include <ctime>
#include <cctype>
#include <algorithm>
#include <string>
#include <iostream>
#include <vector>
#include <sstream>
using namespace std;

#include <boost/regex.hpp>
using namespace boost;

/*
Foo_1_Bar_2015.jpg
Foo_1_Bar_2016.jpg
Foo_2_Bar_2016.jpg
Foo_2_Bar_2015.jpg
...
*/
vector<string> generateNames(int lenPerYear, int yearStart, int years);

/*
Foo_1_Bar_2015.jpg -> 1_2015.jpg
Foo_7_Bar_2016.jpg -> 7_2016.jpg
*/

void rename_method_string(const vector<string> & names, vector<string> & renamed);
void rename_method_regex(const vector<string> & names, vector<string> & renamed);

typedef void rename_method_t(const vector<string> & names, vector<string> & renamed);
void testMethod(const vector<string> & names, const string & description, rename_method_t method);

int main()
{
    vector<string> names = generateNames(10000, 2014, 100);
    cout << "names.size() = " << names.size() << '\n';
    cout << '\n';
    testMethod(names, "method 1 - string manipulation: ", rename_method_string);
    cout << '\n';
    testMethod(names, "method 2 - regular expressions: ", rename_method_regex);

    return 0;
}

void testMethod(const vector<string> & names, const string & description, rename_method_t method)
{
    vector<string> renamed(names.size());
    clock_t timeStart = clock();
    method(names, renamed);
    clock_t timeEnd = clock();
    cout << "renamed examples:\n";
    for (int i = 0; i < 10 && i < names.size(); ++i)
        cout << names[i] << " -> " << renamed[i] << '\n';
    cout << description << 1000 * (timeEnd - timeStart) / CLOCKS_PER_SEC << " ms\n";
}

vector<string> generateNames(int lenPerYear, int yearStart, int years)
{
    vector<string> result;
    for (int year = yearStart, yearEnd = yearStart + years; year < yearEnd; ++year)
    {
        for (int i = 0; i < lenPerYear; ++i)
        {
            ostringstream oss;
            oss << "Foo_" << i << "_Bar_" << year << ".jpg";
            result.push_back(oss.str());
        }
    }
    return result;
}

template<typename T>
bool equal_safe(T itShort, T itShortEnd, T itLong, T itLongEnd)
{
    if (itLongEnd - itLong < itShortEnd - itShort)
        return false;
    return equal(itShort, itShortEnd, itLong);
}

void rename_method_string(const vector<string> & names, vector<string> & renamed)
{
    //manually: "Foo_(\\d+)_Bar_(\\d+).jpg" -> \1_\2.jpg
    const string foo = "Foo_", bar = "_Bar_", jpg = ".jpg";

    for (int i = 0; i < names.size(); ++i)
    {
        const string & name = names[i];
        //starts with foo?
        if (!equal_safe(foo.begin(), foo.end(), name.begin(), name.end()))
        {
            renamed[i] = "ERROR no foo";
            continue;
        }
        //extract number
        auto it = name.begin() + foo.size();
        for (; it != name.end() && isdigit(*it); ++it) {}
        string str_num1(name.begin() + foo.size(), it);
        //continues with bar?
        if (!equal_safe(bar.begin(), bar.end(), it, name.end()))
        {
            renamed[i] = "ERROR no bar";
            continue;
        }
        //extract number
        it += bar.size();
        auto itStart = it;
        for (; it != name.end() && isdigit(*it); ++it) {}
        string str_num2(itStart, it);
        //check *.jpg
        if (!equal_safe(jpg.begin(), jpg.end(), it, name.end()))
        {
            renamed[i] = "ERROR no .jpg";
            continue;
        }
        renamed[i] = str_num1 + "_" + str_num2 + ".jpg";
    }
}

void rename_method_regex(const vector<string> & names, vector<string> & renamed)
{
    regex searching("Foo_(\\d+)_Bar_(\\d+).jpg");
    smatch found;
    for (int i = 0; i < names.size(); ++i)
    {
        if (regex_search(names[i], found, searching))
        {
            if (3 != found.size())
                renamed[i] = "ERROR weird match";
            else
                renamed[i] = found[1].str() + "_" + found[2].str() + ".jpg";
        }
        else renamed[i] = "ERROR no match";
    }
}

它为我生成输出:

names.size() = 1000000

renamed examples:
Foo_0_Bar_2014.jpg -> 0_2014.jpg
Foo_1_Bar_2014.jpg -> 1_2014.jpg
Foo_2_Bar_2014.jpg -> 2_2014.jpg
Foo_3_Bar_2014.jpg -> 3_2014.jpg
Foo_4_Bar_2014.jpg -> 4_2014.jpg
Foo_5_Bar_2014.jpg -> 5_2014.jpg
Foo_6_Bar_2014.jpg -> 6_2014.jpg
Foo_7_Bar_2014.jpg -> 7_2014.jpg
Foo_8_Bar_2014.jpg -> 8_2014.jpg
Foo_9_Bar_2014.jpg -> 9_2014.jpg
method 1 - string manipulation: 421 ms

renamed examples:
Foo_0_Bar_2014.jpg -> 0_2014.jpg
Foo_1_Bar_2014.jpg -> 1_2014.jpg
Foo_2_Bar_2014.jpg -> 2_2014.jpg
Foo_3_Bar_2014.jpg -> 3_2014.jpg
Foo_4_Bar_2014.jpg -> 4_2014.jpg
Foo_5_Bar_2014.jpg -> 5_2014.jpg
Foo_6_Bar_2014.jpg -> 6_2014.jpg
Foo_7_Bar_2014.jpg -> 7_2014.jpg
Foo_8_Bar_2014.jpg -> 8_2014.jpg
Foo_9_Bar_2014.jpg -> 9_2014.jpg
method 2 - regular expressions: 796 ms

此外，我认为这完全没有意义，因为在您的示例中，实际 I/O(获取文件名、重命名文件)将比任何 CPU 字符串操作慢得多。所以回答你的问题:

1. 我没有看到任何更好的方法，I/O 很慢，不要为优越感而烦恼
2. 根据我的经验，regex 对象并不昂贵，与手动方法相比，减速在 2 倍以内，与它节省的工作量相比，这是持续的减速并且可以忽略不计
3. 多少个 std::regex 对象对应多少个 regex_match 调用？取决于 regex_match 调用的数量:匹配越多，创建特定的 std::regex 对象就越值得。然而，这将非常依赖库。如果有很多匹配调用，请单独创建，如果您不确定，请不要打扰。