根据类模板参数对类成员使用不同的构造函数-解网

问：

存在这样一种情况：模板化类包含模板化成员，并且必须使用正确的构造函数（取决于类模板）构造该成员对象。简化示例：

#include <stdexcept>
#include <memory>
#include <iostream>
#include <vector>

template<int N=0>
struct A
{
    const int n_;

    A(int n, double)
        : n_{n}
    {
        static_assert(N <= 0);
    }

    A(double)
        : n_{N}
    {
        static_assert(N > 0);
    }
};


template<int N=0>
struct B
{
    const std::vector<int> m_;

    // Solution with unique_ptr class member to an A<N> object
    std::unique_ptr<A<N>> a_uptr_;
    B(const std::vector<int>& m, double x)
        :   m_{m},
            a_uptr_{N > 0 ? std::make_unique<A<N>>(x) : std::make_unique<A<N>>(m.size(), x)}
    {}


    // Solution with class member A<N> object
    // A<N> a_;
    // B(const std::vector<int>& m, double x)
    //  :   m_{m},
    //      a_{  <????????????????????> }
    // {}
};

int main()
{
    std::vector<int> m{1,2,3};
    B b1(m, 0);
    B<2> b2(m, 0); 
    std::cout << b1.a_uptr_->n_ << ", " << b2.a_uptr_->n_ << std::endl;
}

Q1：有没有办法只有一个类成员（而不是唯一的 ptr）并让它调用正确的构造函数？使用也许???A<N>std::integer_sequence

（Q2：我是不是想多了，即我真的应该担心必须将 obj 放在堆上的性能吗？A<N>

C++ 构造函数 C++17 initializer-list

#include <stdexcept>
#include <iostream>
#include <vector>

template<int N=0>
struct A {
    const int n_;   
    A(int n, double) : n_{n} {
        if constexpr (N > 0) throw  std::runtime_error("wrong constructor for N > 0");
    }

    A(double) : n_{N} {
        if constexpr (N <= 0) throw std::runtime_error("wrong constructor for N <= 0");
    }
};


template<int N=0>
struct B {
    const std::vector<int> m_;    
    A<N> a_uptr_;
    B(const std::vector<int>& m, double x) 
      :   m_{m},
          a_uptr_{make_AN(m,x)}
    {}
private:
    static A<N> make_AN(const std::vector<int>& m,double x) {
        if constexpr (N>0) return x;
        else return {m.size(),x};
    }
};

int main() {
    std::vector<int> m{1,2,3};
    B b1(m, 0);
    B<2> b2(m, 0); 
    std::cout << b1.a_uptr_.n_ << ", " << b2.a_uptr_.n_ << std::endl;
}

或者正如评论中提到的（一些程序员家伙和 n.m.），简单地.也许你害怕无论如何都被省略的副本。a_{N > 0 ? A<N>{m} : A<N>{m, x}}

但是，您应该考虑重写，以便使用和调用时出现编译时错误。AA<N>::A(int,double)N > 0A<N>::A(double)N <= 0

根据类模板参数对类成员使用不同的构造函数

Use different constructor for class member based on class template parameter

评论

评论