Question

我有一个模板类

template <typename T>
class foo;

T有2个有效值，对应于：

using fooT1 = class foo<T1>;
using fooT2 = class foo<T2>;

我想写代码如下：

const auto* fooPtr = useFooT1 ? getFooT1Ptr() : getFooT2Ptr();

因为此函数中使用fooPtr的代码不依赖于fooPtr是fooT1还是fooT2

但是，我收到以下编译器错误：

error: conditional expression between distinct pointer types ...

据我所知，根据C ++标准，应该有一个可以同时投放的普通类型，因此这种方法可能无效。

在不复制大量代码的情况下实现此功能的好方法是什么？

Answer 1

实际上，C ++是静态类型的，因此变量的类型不能依赖于运行时条件。

相反，将通用代码放入模板中：

template <typename T> doStuff(foo<T> * f) {
    // stuff that works with any `foo` type
}

并根据运行时变量

调用不同的专业化

if (useFooT1) {
    doStuff(getFooT1Ptr());
} else {
    doStuff(getFooT2Ptr());
}

Answer 2

如果在编译时已知布尔变量useFooT1，则可以实现编译时开关，如

FooT1 const* getFooPtr(std::true_type /* useFooT1 */) { 
    return getFooT1Ptr(); 
}
FooT2 const* getFooPtr(std::false_type /* !useFooT1 */) { 
    return getFooT2Ptr(); 
}
/* ... */
auto const* fooPtr = getFooPtr(std::integral_constant<bool, useFooT1>());

这也可以推广到两种以上，并且开关可以直接依赖于T1 / T2类型。

另请参阅：Is it possible to use tag dispatching to determine return type和Switch passed type from template以及其他许多内容。

Answer 3

下面是一个示例（实际上有两种不同的方法：V1 / V2），如何使用一个可以在内部使用不同类型的std :: container的函数。请注意，所使用的容器类型实际上可以改变函数的结果（因为容器的内部排序），这是我在这里展示的。函数returnMaxPointV1 / 2采用bool参数，内部具有部分通用代码和部分专用代码。这与使用模板的方法相反，其中函数调用者必须是专用的（！在编译时！），但函数体是通用的。这里调用者是通用的（！在运行时！），但是主体是专用的。

#include <vector>
#include <set>
#include <iostream>
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds

struct Point2D {
    int x1;
    int x2;

    bool operator < (const Point2D& rhs) const {
        return x1-10*x2 < rhs.x1-10*rhs.x2;
    }
};


Point2D points[4] = { { 10,2 },{ 2,2 },{ 0,1 },{ 10,4 } };


namespace returnMaxInlines
{
    inline  Point2D FindMax(Point2D a, Point2D b) {
        return (a.x1 > b.x1) ? a : b;
    }
}

/*
The function returnMaxPoint fills a container with points that satisfy the condition x2 >= 2.
You can select what kind of containter to use  by using the bool containterTypeSet
the function then finds the point with maximum x1 in the container, but because
there are some points with the same x1 it will return the first one encountered,
which may be a different one depending on the container type,
because the points may be differently ordered in the container.
*/
Point2D returnMaxPointV1(bool containterTypeSet)
{
    using namespace returnMaxInlines;       // the inline function is only accessible locally in this function (because of the namespace)

    Point2D     maxPoint = { 0,0 };
    if (containterTypeSet == true) {
        std::set<Point2D>   container;
        for (int cnt = 0; cnt < 4; ++cnt) {
            if (points[cnt].x2 >= 2) {
                container.insert(points[cnt]);
            }
        }
        for (auto it = container.begin(); it != container.end(); ++it) {
            maxPoint = FindMax(maxPoint, *it);      // this part of the code is generic for both cases of bool containterTypeSet, it is an inline function
        }
    }
    else {
        std::vector<Point2D>    container;
        for (int cnt = 0; cnt < 4; ++cnt) {
            if (points[cnt].x2 >= 2) {
                container.push_back(points[cnt]);
            }
        }
        for (auto it = container.begin(); it != container.end(); ++it) {
            maxPoint = FindMax(maxPoint, *it);      // this part of the code is generic for both cases of bool containterTypeSet, it is an inline function
        }
    }
    return maxPoint;
}

/* Alternative implementation
    No inline function is needed, but you need to have all variables for both options declared in scope
    and you need to add many if-statements, thus branching (but maybe the compiler can optimize this out (which will yield some kind of version V1)
*/

Point2D returnMaxPointV2(bool containterTypeSet)
{
    Point2D                 maxPoint = { 0,0 };
    std::set<Point2D>       containerSet;
    std::vector<Point2D>    containerVector;

    // specialized code
    if (containterTypeSet) {
        for (int cnt = 0; cnt < 4; ++cnt) {
            if (points[cnt].x2 >= 2) {
                containerSet.insert(points[cnt]);
            }
        }
    }
    else{
        for (int cnt = 0; cnt < 4; ++cnt) {
            if (points[cnt].x2 >= 2) {
                containerVector.push_back(points[cnt]);
            }
        }
    }
    std::set<Point2D>::iterator         SetIterator;
    std::vector<Point2D>::iterator      VectorIterator;

    const Point2D   *ScopePoint;
    bool            foolCompiler;       // the compiler was tripping if both types of the tenary operator (?:) were not of the same type, so I made the statement such that the statement was of type bool.

    for(foolCompiler = containterTypeSet? ((SetIterator = containerSet.begin()) == SetIterator): ((VectorIterator = containerVector.begin()) == VectorIterator);
        containterTypeSet ? SetIterator != containerSet.end() : VectorIterator != containerVector.end();
        foolCompiler = containterTypeSet ? ((SetIterator++) == SetIterator) : ((VectorIterator++) == VectorIterator)
        ){
        ScopePoint = containterTypeSet ? &(*SetIterator) : &(*VectorIterator);
        // generic code 
        maxPoint = (maxPoint.x1 > ScopePoint->x1) ? maxPoint : *ScopePoint;
    }

    return maxPoint;
}

int main()
{
    Point2D result;

    result = returnMaxPointV1(true);
    std::cout << "result1: (" << result.x1 << "," << result.x2 << ")" << std::endl;
    result = returnMaxPointV1(false);
    std::cout << "result2: (" << result.x1 << "," << result.x2 << ")" << std::endl;

    result = returnMaxPointV2(true);
    std::cout << "result3: (" << result.x1 << "," << result.x2 << ")" << std::endl;
    result = returnMaxPointV2(false);
    std::cout << "result4: (" << result.x1 << "," << result.x2 << ")" << std::endl;

    std::this_thread::sleep_for(std::chrono::seconds(10));
}

该计划的输出是：

result1: (10,2)
result2: (10,4)
result3: (10,2)
result4: (10,4)

auto使用三元运算符和模板

3 个答案: