7

我喜欢向量,通常在数组上使用它们。出于这个原因,我创建了一个模板化的可变参数函数来初始化向量(包括在下面)。

标题(.h):

template <typename T>
vector<T> initVector(const int argCount, T first, ...);

来源(.hpp):

template <typename T>
vector<T> initVector(const int argCount, T first, ...) {
    vector<T> retVec;
    retVec.resize(argCount);

    if(argCount < 1) { ... }

    retVec[0] = first;

    va_list valist;
    va_start(valist, first);
    for(int i = 0; i < argCount-1; i++) { retVec[i+1] = va_arg(valist, T); }
    va_end(valist);

    return retVec;
}

它适用于大多数类型(例如 int、double ...),但不适用于字符串——因为编译器将它们解释为 'const char *',因此

vector<string> strvec = initVector(2, "string one", "string two");

给我错误:

error: conversion from ‘std::vector<const char*, std::allocator<const char*> >’ to non-scalar type ‘std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >’ requested

有没有办法让字符串参数被解释为字符串,而不必强制转换每个参数?

4

2 回答 2

4

因为常量的类型"string one"const char*而不是std::string需要进行转换。va_arg不能进行这种转换,所以我们需要第二个模板参数:

template <typename VecT, typename EleT>
std::vector<VecT> init_vector(const size_t nargs, EleT first, ...) {
    std::vector<VecT> result;
    result.reserve(nargs);

    if (nargs == 0) {
        return result;
    }

    result.push_back(first);

    if (nargs == 1) {
        return result;
    }

    va_list valist;
    va_start(valist, first);

    for (int i = 1; i < nargs; ++i) {
        result.push_back(VecT(va_arg(valist, EleT)));
    }

    va_end(valist);

    return result;
}

std::vector<std::string> = init_vector<std::string>(2, "string one", "string two")

请注意,我做了一些更改,最明显的是更改resizereserve,以防止创建不必要的对象。


您也可以简单地使用它(没有元素数量混乱的风险,并且类型安全):

const char *args[] = {"string one" , "string two"};
std::vector<std::string> strvec(args, args + sizeof(args)/sizeof(args[0]))

或者使用 C++11 初始化列表:

std::vector<std::string> strvec = {"string one" , "string two"};

为了好玩,我做了这个更整洁、更安全的小东西,但不会泛化为任意数量的论点。它通过重载工作。以下是前三个重载和示例用法:

template<class C>
inline C init_container() {
    return C();
}

template<class C, class T>
inline C init_container(T arg0) {
    const T args[1] = {arg0};
    return C(args, args + 1);
}

template<class C, class T>
inline C init_container(T arg0, T arg1) {
    const T args[2] = {arg0, arg1};
    return C(args, args + 2);
}

std::vector<std::string> vec =
    init_container< std::vector<std::string> >("hello", "world");

可以在此处下载完整的标头(最多 100 个参数):https ://gist.github.com/3419369 。

于 2012-08-21T19:42:09.400 回答
1

尝试使用 2 个模板类型参数:

template <typename T, typename U>
vector<T> initVector(const int argCount, U first, ...) {

很多时候(例如 forintdoubleT并且U将是相同的。但新策略的不同之处在于,我们现在允许它们不同,前提是存在从 to 的隐式转换UT例如 from const char*to string)。从某种意义上说,这应该是安全的,如果不存在隐式转换,您将收到编译时错误。

顺便说一句,有趣的策略——我从来没有想过va_listetc. 可以以这种方式使用!OTOH,我相信 C++11 中有新的机制允许从初始化列表直接初始化向量等,类似于你一直能够在 C 中初始化数组的方式int a[] = { 3, 4, 5 };,所以最好使用它.

于 2012-08-21T19:50:35.560 回答