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

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

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

现在，我能想到以下两种方法：

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

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;
}

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

2) 正则表达式

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

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

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

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

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

我需要知道的：

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

Answer 1

为什么不使用 split 来拆分字母和数字之间的字符串：

Regex.Split(fileName, "(?<=\\D)(?=\\d)|(?<=\\d)(?=\\D)");

然后获取数字所需的任何索引，可能使用 Where 子句来查找值增加的索引，而其他索引匹配，然后您可以使用 .Last() 获取扩展名。

Answer 2

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

可运行的完整代码示例（与 boost_system 和 boost_regex 链接，或者如果编译器中已经有 regex，则更改包含）：

#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. 根据我的经验，正则表达式对象并不昂贵，在 2 倍的减速与手动方法之间，与它节省的工作量相比，它持续减速并且可以忽略不计
3. 多少个 regex_match 调用有多少个 std::regex 对象？取决于 regex_match 调用的数量：匹配越多，创建特定的 std::regex 对象就越值得。但是，这将非常依赖于库。如果有很多匹配调用，请单独创建，如果不确定，请不要打扰。