C ++：模板类二进制运算符重载-seg错误？

Question

The following describe the example I have which works:

header :

const size_t N = 10;
//    template<size_t N>
class SymbolicMonomial {
public:
    int powers[N];
    int constant;

    SymbolicMonomial() {
        for (int i = 0; i < N; i++) {
            this->powers[i] = 0;
        }
        this->constant = 1;
    }

    SymbolicMonomial(int variable): SymbolicMonomial(){
        this->powers[variable] = 1;
    }

    static SymbolicMonomial as_monomial(int value){
        auto result = SymbolicMonomial();
        result.constant = value;
        return result;
    }

    bool is_constant(){
        for(int i=0;i<N;i++){
            if(this->powers[i] > 0){
                return false;
            }
        }
        return true;
    }
};

//    template<size_t N>
std::ostream &operator<<(std::ostream &out, const SymbolicMonomial value){
    out << value.constant << "(";
    for(int i=0;i<N-1;i++){
        out << value.powers[i] << ", ";
    }
    out << value.powers[N-1] << ")";
}

//    template<size_t N>
SymbolicMonomial operator*(SymbolicMonomial lhs, SymbolicMonomial rhs) {
    SymbolicMonomial result = SymbolicMonomial();
    for (int i = 0; i < N; i++) {
        result.powers[i] = lhs.powers[i] + rhs.powers[i];
    }
    result.constant = lhs.constant * rhs.constant;
    return result;
}

The main.cpp :

int main(int argc, char *argv[])
{
auto t_a = symbolic::SymbolicMonomial(2);
auto t_b = symbolic::SymbolicMonomial(1);
auto t_c = t_b*t_a*t_a;
std::cout << t_c << std::endl;
return 0;
}

And everything is fine. However, I wanted to change the whole thing to have a template argument <N> instead of a constant. Thus this is the templated code: header.h :

template<const size_t N>
class SymbolicMonomial {
public:
    int powers[N];
    int constant;

    SymbolicMonomial() {
        for (int i = 0; i < N; i++) {
            this->powers[i] = 0;
        }
        this->constant = 1;
    }

    SymbolicMonomial(int variable): SymbolicMonomial(){
        this->powers[variable] = 1;
    }

    static SymbolicMonomial as_monomial(int value){
        auto result = SymbolicMonomial<N>();
        result.constant = value;
        return result;
    }

    bool is_constant(){
        for(int i=0;i<N;i++){
            if(this->powers[i] > 0){
                return false;
            }
        }
        return true;
    }
};

template<const size_t N>
std::ostream &operator<<(std::ostream &out, const SymbolicMonomial<N> value){
    out << value.constant << "(";
    for(int i=0;i<N-1;i++){
        out << value.powers[i] << ", ";
    }
    out << value.powers[N-1] << ")";
}

template<const size_t N>
SymbolicMonomial<N> operator*(SymbolicMonomial<N> lhs, SymbolicMonomial<N> rhs) {
    SymbolicMonomial<N> result = SymbolicMonomial<N>();
    for (int i = 0; i < N; i++) {
        result.powers[i] = lhs.powers[i] + rhs.powers[i];
    }
    result.constant = lhs.constant * rhs.constant;
    return result;
}

And main.cpp :

int main(int argc, char *argv[])
{
auto t_a = symbolic::SymbolicMonomial<10>(2);
auto t_b = symbolic::SymbolicMonomial<10>(1);
auto t_c = t_b*t_a*t_a;
std::cout << t_c << std::endl;
return 0;
}

Now the non template version works as expected, however the templated one fails with code 139 (SEGFAULT). Firstly, I do not understand why the code fails if someone can explain and secondly how to fix it?

Answer 1

std::ostream &operator<<(std::ostream &out, const SymbolicMonomial<N> value) isn't returning a value. For me, in Visual Studio, that resulted in a compile error. Adding return out; to the end of the function lead to the code working without an ACCESS_VIOLATION (Windows flavor of a SEGFAULT).

All of your bound-checking looks correct, so, if I had to guess, I'd say that your compiler is ignoring the missing return, and you're entering a spooky space known as undefined behavior when you work with a return value that was never actually set.

Assuming you're using GCC, you can set -Werror=return-type to throw compile errors when you make these kinds of mistakes.