无法从 'initializer list' 转换为模板 <int>

Question

那是我的 class:

我正在重载运算符&&以确定一个间隔是否与给定间隔有任何共同点，我试图在它们没有任何共同点时例外，所以它会 return具有两个相同值的间隔，必须在构造函数中打印 "EMPTY"，但由于初始化列表的原因，它不会编译。我的 class：（删除了所有不相关的功能）

class Interval
{
public:
    friend ostream & operator<<(ostream &output, const Interval<T> & it) {
        if (&it)
            it.print();
        return output;
    }
    friend istream & operator>>(istream &input, Interval<T> & it) {
        it.enter();
        return input;
    }
    Interval();
    Interval(const T &, const T &);
    Interval<T> operator&&(Interval<T> &it);
    Interval<T> operator||(Interval<T> &it);
    ~Interval();
private:
    T a;
    T b;
    int flag;
};

重载函数&&:

template <class T>
Interval<T> Interval<T>::operator&&(Interval<T> &i1) {
    if (b < i1.a)
        return Interval<T>(i1, i1);
    else if (b == i1.a) 
        return Interval<T>(i1, i1);
    else if (a > i1.b) 
        return Interval<T>(i1, i1);
    else if (a == i1.b) 
        return Interval<T>(i1, i1);
    else {
        if (a<i1.a){
            if (b < i1.b)
                return Interval<T>(i1.a, b);
            else return Interval<T>(i1.a, i1.b);
        }
        if (i1.a < a) {
            if (i1.b < b)
                return Interval<T>(a, i1.b);
            else return Interval<T>(a, b);
        }
    }
}

我的构造函数：

Interval<T>::Interval(const T &t1, const T &t2) {
    a = t1;
    b = t2;
    if (t1 == t2) {
        cout << "EMPTY";
    }
    flag = 0;
}

这是我因该问题收到的警告。

Error   C2440   '<function-style-cast>': cannot convert from 'initializer list' to 'Interval<int>'

我做的有什么问题吗？

Answer 1

你的代码中有很多错误。

我猜你的 class 上面有一个 template <typename T>，或者整个代码都是错误的

最重要的是在你的运算符里面&&

您只声明了一个带有 2 个参数的构造函数，均为 const T&。然而在你的成员函数中，你将构造函数调用与

const T&, const T&
const Interval<T>&, const Interval<T>&
const T&, const Interval<T>&
const Interval<T>&, const T&

其中一些调用将失败，因为您只提供了以下构造函数。

Interval();
Interval(const T &, const T &);
// and copy/move constructors, if possible

你的流运算符也有问题，你接受了一个流，但你忽略了它，你通过一个 const 引用接受你的参数，但你检查它是否不是 nullptr，引用不能是 "made" 来自 nullptr，这是不屈不挠的行为。

作为旁注，请尝试使用不同的编译器编写您的代码，clang 会给出以下警告，更具可读性。

<source>:31:16: error: no matching constructor for initialization of 'Interval<int>'
        return Interval<T>(i1, i1);
               ^           ~~~~~~

<source>:65:7: note: in instantiation of member function 'Interval<int>::operator&&' requested here
    x && y;

Answer 2

Error   C2440   '<function-style-cast>': cannot convert from 'initializer list'
                 to 'Interval<int>'

no matching constructor for initialization of 'Interval<int>'
       return Interval<T>(i1, i1);

您没有构造函数采用两个 Interval<T> 和 i1 是一个 Interval<T>。您必须使用两个 T（在本例中为 int:s）构建它。

建议：&&通常用于结果为true或false的布尔运算。如果要returna ∩ b（交集），我觉得T T::operator&(const T2 &b) const;会更合适。注意 const:s！您不应该更改任何值，但是 return 一个新建的 Interval<T>.

此外，if(&it) 不是必需的。 it 是 const Interval<T>&（引用）- 并且引用必须始终引用某些内容，因此，&it 不能 return nullptr。另一方面，如果 it 是 const Interval<T>*（指针），那么它可能是 nullptr，那么检查就有意义了。这样的参考文献很好！

另一个注意事项：您不必在 class 定义中的 Interval 之后使用 <T>。 Interval 默认表示 Interval<T>。仅当您想将它与另一种 Interval 类型混合时，您才需要为其提供类型。喜欢：

template<typename T>
class Interval {
    template<typename U>
    void something(Interval& a, Interval<U>& b) {
        // a is an Interval<T>&
        // b is an Interval<U>&
    }
};

您也不需要创建流媒体运营商 friend，因为他们不直接访问 private 成员。您有 print() 和 enter() 成员函数。

以下是代码中带有注释的更多详细信息和建议：

#include <algorithm>  // std::min, std::max
#include <iostream>

// half-open interval:  [a, b)
template<typename T>
class Interval
{
public:
    // default constructs an empty interval
    Interval() : 
        Interval({}, {})  // delegating to the below constructor
    {}

    Interval(const T& t1, const T& t2) : // <- use the member initializer list
        a{t1},
        b{t2},
        flag{0}
    {
        if(b < a) b = a; // illegal, make it empty
        if(a == b) std::cout << "EMPTY\n";
    }

    // itersection
    Interval operator&(const Interval& it) const {
        // Construct the Interval<T> using copy-list-initialization.
        // A return statement with braced-init-list used as the return expression
        // and list-initialization initializes the returned object.

        return  {
                    std::max(a, it.a), // get the greatest lower bound
                    std::min(b, it.b)  // get the smallest upper bound
                };
    }

    std::ostream& print(std::ostream& os) const {        
        return os << '[' << a << ',' << b << ')';
    }

    std::istream& enter(std::istream& is) {        
        return is >> a >> b;
    }

private:
    T a;
    T b;
    int flag;
};

// streaming operators do not need to be friends since they use public member functions
template<typename T>
std::ostream& operator<<(std::ostream& output, const Interval<T>& it) {
    return it.print(output);
}

template<typename T>
std::istream& operator>>(std::istream& input, Interval<T>& it) {
    return it.enter(input);
}

int main() {
    Interval<int> x(0, 10);
    Interval<int> y(5, 15);

    Interval<int> u; // using the new default constructor
    u = x & y;
    std::cout << u << '\n'; // [5,10)

    std::cout << (Interval<int>(0,20) & Interval<int>(5,15)) << '\n'; // [5,15)
    std::cout << (Interval<int>(0,10) & Interval<int>(10,20)) << '\n'; // EMPTY [10,10)
    std::cout << (Interval<int>(100,200) & Interval<int>(0,100)) << '\n'; // EMPTY [100,100)
}

无法从 'initializer list' 转换为模板 <int>

cannot convert from 'initializer list' to template<int>

c++

initialization

initializer-list

visual-c++