标签: template-meta-programming

如果a,b,c,..表示 类型，则令 为我正在寻找地图的(a,b)类型， ，这样std::pair<a,b>F

    F : ((((a,b),c),d),...))) -> std::tuple<a,b,c,d...>

它是否以标准库中的某个现有名称存在？如果没有，是否有另一个库可以做到这一点，或者这很容易实现，但我太笨了，不知道该怎么做？

是否可以std::bind_front在 C++17 中轻松模仿？（仅对于成员函数包装就可以）

我查看了c++20中的实现，旨在复制，但看起来它确实非常具体的实现。

我在想 lambda 包装器或模板函数/对象可能有用吗？

（这里性能不是问题）

最近我发现了这个关于使用模板展开循环的StackOverflow 答案。答案指出“这个想法适用于 C++11”，我最终得到了这个：

namespace tmpl {
  namespace details {
    template<class T, T... values>
    class integer_sequence {
    public:
      static constexpr size_t size() { return sizeof...(values); }
    };
    
    template<class T, class N, class... Is>
    struct make_integer_sequence_helper :
      make_integer_sequence_helper<T, std::integral_constant<T, N::value - 1>, std::integral_constant<T, N::value - 1>, Is...> {};
      
    template<class T, class... Is>
    struct make_integer_sequence_helper<T, std::integral_constant<T, 0>, Is...> {
      using type = integer_sequence<T, Is::value...>;
    };
    
    template<class T, T N>
    using make_integer_sequence = typename make_integer_sequence_helper<T, std::integral_constant<T, N>>::type;
    
    template<class... Ts>
    void variadic_noop(Ts... params) …

如果可能，我如何在具有模板类型的函数中使用某些特定于类型的函数（例如.size()for: std::stringor std::vectoror ...），确保当我使用该特定于类型的函数时我实际上正在调用它以正确的类型作为参数？也许我错了，如果是的话，请向我解释我必须做什么。

#include <iostream>
#include <string>

template <typename T>
std::string func(T& number) {
    if (typeid(T) == typeid(std::string)) {
        unsigned short int size = number.size();// !
        return " is a string";
    }
    else if (typeid(T) == typeid(int)) {
        return " is an int";
    }
    //...
}

int main() {
    std::string name = "Anthony";
    int age = 8;
    std::cout << name /*<< func(name) */<< '\n' << age << func(age) << '.';
    return 0;
}

我知道在上面的代码中：

unsigned …

template <template <typename...> typename T, template <typename...> typename U>
struct is_same_template : std::false_type {};

template <template <typename...> typename T>
struct is_same_template<T, T> : std::true_type {};

template <template <typename...> typename T, template <typename...> typename U>
constexpr bool is_same_template_v = is_same_template<T, U>::value;

上面的实现is_same_template可以导致下面的两条语句编译。

static_assert(is_same_template_v<std::map, std::map>);
static_assert(!is_same_template_v<std::map, std::vector>);

是否可以增强is_same_template以下语句的编译能力？

static_assert(is_same_template_v<std::map<int, bool>, std::map>);
static_assert(is_same_template_v<std::map<int, bool>, std::map<int, int>>);
static_assert(!is_same_template_v<std::map<int, bool>, std::vector>);
static_assert(!is_same_template_v<std::map<int, bool>, std::vector<int>>);

这不是链接的重复项

考虑以下代码：

#include <type_traits>

template <typename... Bases>
struct Overloads : public Bases... {};

template <typename T>
struct A {
  using AType = T;
};

template <typename T>
struct B {
  using BType = T;
};

template <typename T>
struct C {
  using CType = T;
};

template <typename OverloadsType>
struct Derived : public OverloadsType {
  
};

int main() {
    // OK
    static_assert(std::is_same_v<typename Derived<Overloads<A<int>, B<float>, C<char>>>::AType, int>);
    // OK
    static_assert(std::is_same_v<typename Derived<Overloads<A<int>, B<float>, C<char>>>::BType, float>);
    // OK
    static_assert(std::is_same_v<typename Derived<Overloads<A<int>, B<float>, C<char>>>::CType, …

下面的代码示例尝试提取foo先前输入到函数中的结构的成员指针的值类型serialize()。

这可能需要进一步解释：我想最终迭代结构体的每个成员foo，并根据每个成员指针的值类型应用某些操作。看一看：

演示

#include <cstdio>
#include <utility>
#include <tuple>
#include <typeinfo>

/* Struct with two int members */

struct foo
{
    int a_;
    int b_;
};

/* Saves member pointers */

template<auto Ptr>
struct proxy
{
    decltype(Ptr) mem_ptr_;
};

/* Conglomerate of all member ptrs of a struct */

template <typename T>
struct type_descriptor;

template <>
struct type_descriptor<foo>
{
    using type = std::tuple<proxy<&foo::a_>, proxy<&foo::b_>>;
};

/* Extract member ptr value type */

template<typename T> …

我有一个名为 的类型the_bad。the_good我想用模板元函数替换该类型。我预计该模板元函数会非常复杂，因此我们将其称为the_ugly.

我的问题是它the_bad可以嵌套在其他模板中，并且我想保持其他模板和参数不变。这是我的意思的一个例子，其中的实现不完整the_ugly：

struct the_good {};
struct the_bad {};

template<typename T>
struct the_ugly_impl {
    using type = T;
};

template<>
struct the_ugly_impl<the_bad> {
    using type = the_good;
};

template<typename T>
using the_ugly = typename the_ugly_impl<T>::type;

// passes, yay!
static_assert(std::same_as<the_good, the_ugly<the_bad>>);

// doesn't pass
static_assert(std::same_as<std::vector<the_good>, the_ugly<std::vector<the_bad>>>);

// doesn't pass
static_assert(std::same_as<std::list<std::vector<the_good>>, the_ugly<std::list<std::vector<the_bad>>>>);

我该如何修复，the_ugly以便它在任何嵌套级别替换the_bad为，同时保持所有其他模板和其他模板参数不变？the_good

我希望能够做到这样的事情:

template <typename template_type>
class awesome_class{
public:
    void some_function(void){
        // if (template_type == type_a)
        cout << "I am of type_a and doing type_a specific methods";
        // endif

        cout << "I am not of type_a and doing my normal methods";
    }
}

我基本上想扩展一个模板化类,如果它是一个包含特定成员变量的类型,那么运行一些由于成员变量而可能的优化代码,但是如果它不属于那个类型那么只需忽略该部分代码

这在C++中是否可行？或者我是否完全错了？

编辑:我专门的功能基本上要求我这样做几乎班上的每一个功能.那时,我不妨再做一个专门针对有关类型的课程.再次,谢谢你,学到了一些新的和有价值的东西,可能会在其他情况下派上用场!

模板似乎无法对原始操作的结果进行类型推断.例如,以下内容无法推断R:

template<typename A, typename B, typename R>
R addNumbers(A x, B y){
    return x + y;
}
main(){
    addNumbers(1.0f, 1);
}

尽管很清楚float + int = float.

在任何版本的C++中,是否有某种方法可以在不明确指定的情况下将此信息考虑在内？