C++: Template class binary operator overloading - seg fault? - c++

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.