问由于继承，operator<<()不能从模板解析

EN

我认为你对自己的约束太多了:你可以删除基类，为pos_inf和neg_inf添加operator<<，并为limit添加额外的类型，这样你就可以拥有不同类型的两个界限。我的意思是：

Calc.h

#pragma once

#include <cmath>
#include <iostream>
#include <limits>
#include <type_traits> 


struct pos_inf {
    constexpr double operator()() const { return std::numeric_limits<double>::infinity(); }
};

struct neg_inf  {
    constexpr double operator()() const { return -std::numeric_limits<double>::infinity(); }
};
// Both operators defined
std::ostream& operator<<(std::ostream& os, const pos_inf& inf);
std::ostream& operator<<(std::ostream& os, const neg_inf& inf);

//extra template type  in limit
template<typename dX, class lowerBoundType, class UpperBoundType>
class limit {
    dX dx;
    lowerBoundType lowerBound;
    UpperBoundType upperBound;
    double step_size;

public:
    limit(dX x, lowerBoundType lower, UpperBoundType upper, double step = 1) :
        dx{ x }, lowerBound{ lower }, upperBound{ upper }, step_size{ step }
    {}

    dX value() const { return dx; }
    lowerBoundType lower() const { return lowerBound; }
    UpperBoundType upper() const { return upperBound; }
    double step() const { return step_size; }
};

Calc.cpp

#include "calc.h"

std::ostream& operator<<(std::ostream& os, const pos_inf& inf) {
    return os << inf(); // but fails to compile

}

std::ostream& operator<<(std::ostream& os, const neg_inf& inf) {
    return os << inf(); // but fails to compile

}

main.cpp

#include "calc.h"

int main() {
    neg_inf nif;
    pos_inf pif;

    limit<double, neg_inf, pos_inf> l(3.4, nif, pif, 2.2);

        std::cout << "value dx  = " << l.value() << '\n';
        std::cout << "lower lim = " << l.lower() << '\n';
        std::cout << "upper lim = " << l.upper() << '\n';
        std::cout << "step_size = " << l.step() << '\n';

    return EXIT_SUCCESS;
}

如果这不是你想要的，我道歉。

好的，您已经使用const pos_inf& inf和const neg_inf& inf对operator<<进行了重载，但是您使用infinity作为模板类型，因此您的lower()方法返回infinity。当然，您的运算符重载不会被使用，因为它们是从infinity派生的类型。为什么不直接重载infinity的operator<<呢？

一些快速的想法如何解决这个问题：

1. 使double operator()()虚拟化。但是您不能将其与用于limits的constexpr.
2. Using template<typename dX, class lower_bound, class upper_bound>类混合在一起来实际指定这两个边界的类型，然后您的lower和upper方法可以返回pos_inf和neg_inf类型，并且您当前的运算符将起作用。此外，为了简单起见，如果类型不总是不同，您也可以将第二个类型默认为第一个类型- template<typename dX, class lower_bound, class upper_bound = lower_bound>.
3. After提供了更多关于设计的信息-那么为什么不真正地将infinity类模板化(既然我假设您希望它与dX匹配，并在那里实现限制？

#include #include > template struct infinity { public: infinity() = default；constexpr double lower() { return -std::numeric_limits::infinity()；} constexpr double std：：numeric_limits：：infinity(){ return std::numeric_limits::infinity()；} }；模板类限制{ dX dx；double step_size；dX : limit(dX x，double step = 1)：dx{ x }，step_size{ step } {} dX value() const { dX dx；}dX lower() const { return infinity().lower()；}dX upper() const { return infinity().upper()；} double step() const {dX step_size；} }；int main() { limit l(3.4，2.2)；std::cout << "value dx =“<< l.value() << '\n‘<<”下lim =“<< l.lower() << '\n’<<”上lim =“<< l.upper() << '\n‘<< "step_size =”<< l.step() << '\n'；return EXIT_SUCCESS；}Making return。这样，您实际上将从绑定类型到所需值类型的解析保留在模板中，并且您可以混合无限和非无限限制。

#include #include > struct pos_inf { constexpr operator double() const { return std::numeric_limits::infinity()；} }；struct neg_inf { constexpr operator double() const { return -std::numeric_limits::infinity()；} }；template类限制{ dX dx；upper_bound lowerBound；lower_bound upperBound；double step_size；dX : limit(dX x，upper_bound lower，lower_bound upper，double step = 1)：dx{ x }，lowerBound{ lower }，upperBound{ upper }，step_size{ step } {} //对于无穷大，这两个函数将调用运算符double()，对于实际的double，它将返回固定值dX lower() const {upper_bound lowerBound；} dX upper() const {lower_bound upperBound；}dx value() const { return dx；} double step() const { return step_size；} }；int main() { limit l(3.4，pos_inf()，neg_inf()，2.2)；//无限限制l2(3.4，1，5，2.2)；//固定值std::cout << "value dx =“<< l.value() << '\n‘<<”下lim =“<< l.lower() << '\n’<<”上lim =“<< l.upper() << '\n‘<< "step_size =”<< l.step() << '\n'；return EXIT_SUCCESS；}

不要那样重载子类的运算符。使用虚方法进行输出，并将泛型类型与调用虚方法的重载运算符一起使用：

class infinity {
  public:
    virtual ostream &printTo(ostream &o) const = 0;
};
ostream &operator<<(ostream &o,const infinity &i) {
  return i.printTo(o);
}
class neg_inf : public infinity {
  public:
    virtual ostream &printTo(ostream &o) const {
        // do what you want
        return o;
    }
};