在C++17中每次实例化时生成一个新类型

考虑以下代码：

template <class /* Weird Hack Here */>
struct object
{
    constexpr object(int value, /* Other Weird Hack */) noexcept;
};

int main() 
{
    object foo(1);
    object bar(1);
}

---

在C++17中使用奇怪的技巧是否可能使foo和bar成为不同的类型？

真正的答案：不。如果您想要不同的类型，请编写不同的类型。整个概念都是疯狂的

玩具回答，当然。首先，您可以宏输出类型：

template <int N>
struct object {
    object(int ) { }
};

#define object object<__LINE__>

或者，也许只是其中之一：

template <class T>
struct object {
    object(T ) { }
};

#define foo(x) <double> foo(x)

或者，你可以利用黑客入侵不同的价值观。这适用于但不适用于叮当声：

template <int N>
struct flag
{
    friend constexpr int adl_flag(flag<N>);
    constexpr operator int() { return N; }
};

template <int N>
struct write
{
    friend constexpr int adl_flag(flag<N>) { return N; }
    static constexpr int value = N;
};

template <int N, int = adl_flag(flag<N>{})>
constexpr int read(int, flag<N>, int R = read(0, flag<N + 1>{}))
{
    return R;
}

template <int N>
constexpr int read(float, flag<N>)
{
    return N;
}

template <class T, int N=0, int R=write<read(0, flag<0>{})+N>::value>
struct object {
    object(T ) { }
};

---

真正的答案：不。如果你想要不同的类型，写不同的类型。整个概念都是疯狂的

玩具回答，当然。首先，您可以宏输出类型：

template <int N>
struct object {
    object(int ) { }
};

#define object object<__LINE__>

或者，也许只是其中之一：

template <class T>
struct object {
    object(T ) { }
};

#define foo(x) <double> foo(x)

或者，你可以利用黑客入侵不同的价值观。这适用于但不适用于叮当声：

template <int N>
struct flag
{
    friend constexpr int adl_flag(flag<N>);
    constexpr operator int() { return N; }
};

template <int N>
struct write
{
    friend constexpr int adl_flag(flag<N>) { return N; }
    static constexpr int value = N;
};

template <int N, int = adl_flag(flag<N>{})>
constexpr int read(int, flag<N>, int R = read(0, flag<N + 1>{}))
{
    return R;
}

template <int N>
constexpr int read(float, flag<N>)
{
    return N;
}

template <class T, int N=0, int R=write<read(0, flag<0>{})+N>::value>
struct object {
    object(T ) { }
};

---

所以如果我把物体x1；在一个循环中，你希望有无限多的不同类型吗？类似的事情可能是因为，但在未来将被禁止不是C++17，但元类方案会给你强大的typedef，这几乎完成了同样的事情；在一个循环中，您是否希望有无限多的不同类型？类似的情况可能是因为，但在未来将被禁止不是C++17，但元类方案将为您提供强大的typedef，这几乎实现了相同的功能。