name list does not include my class name error

Question

I defined matrix class in matrix.h and I include it and implement it in matrix.cpp but in matrix.cpp compiler says that 'matrix' is not a class, namespace, or enumeration. this error is shown in only constructor and private functions implementation. what's the problem.. *matrix.h

#ifndef MATRIXH
#define MATRIXH

#include <bits/stdc++.h>

using namespace std;

typedef long long biginteger;

template <typename element_type> 
class matrix{
    typedef function<element_type *(matrix &, biginteger, biginteger)> accessor_type;
private:
    biginteger rows,columns;
    element_type *pos;
    accessor_type accessor;
    void allocate_memory();
    void set_basic_accessor();
public:
    // constructors
    matrix();
    matrix(biginteger rows);
    matrix(biginteger rows,biginteger columns);

    matrix(biginteger rows,biginteger columns, element_type x);
    matrix(biginteger rows,biginteger columns, function<element_type(biginteger, biginteger)> f);
    matrix(biginteger rows,biginteger columns, const matrix &m);

    matrix(biginteger rows,biginteger columns, element_type *pos);
    matrix(biginteger rows,biginteger columns, accessor_type accessor);
    matrix(biginteger rows,biginteger columns, element_type *pos, accessor_type accessor);
    
    // getters
    element_type *get_pos();
    biginteger get_rows();
    biginteger get_columns();
    accessor_type get_accessor();

    //setters
    void set_pos(element_type *pos);
    void set_accessor(accessor_type accessor);

    //operators
    element_type &operator ()(biginteger i, biginteger j);//^element accessor
    matrix operator ()(biginteger idx);//^row accessor
    matrix operator[](biginteger idx);//^column accessor

    matrix operator * (matrix a);
    matrix operator + (matrix a);
    matrix operator - (matrix a);
        
    //utilities
    void free();

    element_type max_value();
    element_type min_value();

    matrix foreach_calculate (function<element_type(const element_type &, const element_type &)> f, matrix a);
    matrix pass(function<element_type(element_type)> f);
    matrix pass(function<element_type(biginteger,biginteger,element_type)> f);
    
    matrix t();
    
    string size_info();
    string info();

    bool check_pos(biginteger i, biginteger j);
    bool check_multipliable(matrix &m);
    bool is_same_size(matrix &m);

    biginteger calculate_relpos(biginteger i, biginteger j);
};
#endif

*matrix.cpp

#include <bits/stdc++.h>
using namespace std;

#include "matrix.h"

// constructors

matrix::matrix() :rows(1), columns(1) { 
    allocate_memory();
    set_basic_accessor();
} //error here
matrix::matrix(biginteger rows) : rows(rows),columns(1){
    allocate_memory();
    set_basic_accessor();
} //error here
matrix::matrix(biginteger rows,biginteger columns) : rows(rows),columns(columns){
    allocate_memory();
    set_basic_accessor();
} //error here

matrix::matrix(biginteger rows,biginteger columns, element_type x) : rows(rows),columns(columns){
    allocate_memory();
    set_basic_accessor();
    for(biginteger i=1;i<=rows;i++){
        for(biginteger j=1;j<=rows;j++){
            (*this)(i,j)=x;
        }
    }
} //error here

matrix::matrix(biginteger rows,biginteger columns, const matrix &m) : rows(rows),columns(columns){
    allocate_memory();
    set_basic_accessor();
    for(biginteger i=1;i<=rows;i++){
        for(biginteger j=1;j<=rows;j++){
            (*this)(i,j)=m(i,j);
        }
    }
} //error here

matrix::matrix(biginteger rows,biginteger columns, element_type * pos) : rows(rows),columns(columns), pos(pos) {
    set_basic_accessor();}
matrix::matrix(biginteger rows,biginteger columns, accessor_type accessor) : rows(rows),columns(columns), accessor(accessor){
    allocate_memory();
} //error here
matrix::matrix(biginteger rows,biginteger columns, element_type * pos, accessor_type accessor) : rows(rows),columns(columns), pos(pos), accessor(accessor) {}
matrix::matrix(biginteger rows,biginteger columns, function<element_type(biginteger, biginteger)> f){
    allocate_memory();
    set_basic_accessor();
    for (biginteger i = 1; i <= rows; i++) {
        for (biginteger j = 1; j <= columns; j++) {
            (*this)(i,j) = f(i, j);
        }
    }
} //error here

void matrix::allocate_memory() {
    pos = (element_type *)malloc(sizeof(element_type)*rows*columns);
} //error here

void matrix::set_basic_accessor() {
    accessor = [=](matrix &m, biginteger i,biginteger j) -> element_type* {
        return  m.get_pos()+calculate_relpos(i,j);
    };
} //error here
// getters
element_type matrix::*get_pos() {
    return pos;
}
biginteger matrix::get_rows() {
    return rows;
}
biginteger matrix::get_columns() {
    return columns;
}
accessor_type matrix::get_accessor(){
    return accessor;
}

//setters
void matrix::set_pos(element_type *pos){
    pos=pos;
}
void matrix::set_accessor(accessor_type accessor){
    accessor=accessor;
}

element_type &operator matrix::()(biginteger i, biginteger j){
    if(!check_pos(i,j)){
        throw runtime_error("invalid idx - in element reference");
    }
    return *accessor((*this),i,j);
} //^element accessor
matrix operator matrix::()(biginteger idx){
    if(rows==1){
        return (*this)(1,idx);
    }
    if(columns==1){
        return (*this)(idx,1);
    }
    if(idx<1 or idx>rows){
        throw runtime_error("invalid idx - in row vector refference");
    }
    return matrix(1, columns, pos, [=](matrix &m, biginteger i, biginteger j){
        return pos+calculate_relpos(i,idx);
    });
} //^row accessor
matrix operator matrix::[](biginteger idx) {
    if(rows==1){
        return (*this)(1,idx);
    }
    if(columns==1){
        return (*this)(idx,1);
    }
    if(idx<1 or idx>columns){
        throw runtime_error("in column vector reference");
    }
    return matrix(rows, 1, pos, [=](matrix &m, biginteger i,biginteger j){
        return pos+calculate_relpos(i,idx);
    });
} //^column accessor
matrix operator matrix::* (matrix a) {
    if(!check_multipliable(a)){
        throw runtime_error("in multiply operation, matrix sizes do not match\nfirst matrix:\n"+info()+"second matrix:\n"+a.info());
    }
    matrix<element_type> ret(rows, a.get_columns());
    for (biginteger i = 1; i <= rows; i++) {
        for (biginteger j = 1; j <= a.columns; j++) {
            for (biginteger k = 1; k <= columns; k++) {
                ret(i,j) = ret(i,j) + (*this)(i,k) * a(k,j);
            }
        }
    }
    return ret;
}
matrix operator matrix::+ (matrix a) {
    if(!is_same_size(a)){
        throw runtime_error("in add operation, matrix sizes do not match\nfirst matrix:\n"+info()+"second matrix:\n"+a.info());
    }
    matrix<element_type> ret(rows, columns);
    for (int i = 1; i <= rows; i++) {
        for (int j = 1; j <= columns; j++) {
            ret(i,j) = (*this)(i,j) + a(i,j);
        }
    }
    return ret;
}
matrix operator matrix::- (matrix a) {
    if(!is_same_size(a)){
        throw runtime_error("in sub operation, matrix sizes does not match\nfirst matrix:\n"+info()+"second matrix:\n"+a.info());
    }
    matrix<element_type> ret(rows, columns);
    for (int i = 1; i <= rows; i++) {
        for (int j = 1; j <= columns; j++) {
            ret(i,j) = (*this)(i,j) - a(i,j);
        }
    }
    return ret;
}
    
//utilities
void matrix::free() {
    free(pos);
    pos = NULL;
}
element_type matrix::max_value() {
    element_type ret = (*this)(1,1);
    for(biginteger i=1;i<=rows;i++){
        for(biginteger j=1;j<=columns;j++){
            if((*this)(i,j)>ret){
                ret=(*this)(i,j);
            }
        }
    }
    return ret;
}
element_type matrix::min_value() {
    element_type ret = (*this)(1,1);
    for(biginteger i=1;i<=rows;i++){
        for(biginteger j=1;j<=columns;j++){
            if((*this)(i,j)<ret){
                ret=(*this)(i,j);
            }
        }
    }
    return ret;
}
matrix matrix::foreach_calculate (function<element_type(const element_type &, const element_type &)> f, matrix a) {
    if (!is_same_size(a)) {
        throw runtime_error("in foreach calculate call, matrix sizes does not match\nfirst matrix:\n"+info()+"second matrix:\n"+a.info());
    }
    matrix ret(rows, columns);
    for(biginteger i=1;i<=rows;i++){
        for(biginteger j=1;j<=columns;j++){
            ret(i,j)=f((*this)(i,j),a(i,j));
        }
    }
    return ret;
}
matrix matrix::pass(function<element_type(element_type)> f) {
    matrix ret(rows, columns);
    for (int i = 1; i <= rows; i++) {
        for (int j = 1; j <= columns; j++) {
            ret(i,j)=f((*this)(i,j));
        }
    }
    return ret;
}
matrix matrix::pass(function<element_type(biginteger,biginteger,element_type)> f) {
    matrix ret(rows, columns);
    for (int i = 1; i <= rows; i++) {
        for (int j = 1; j <= columns; j++) {
            ret(i,j)=f(i,j,(*this)(i,j));
        }
    }
    return ret;
}
string matrix::size_info(){
    return "("+to_string(rows)+"*"+to_string(columns)+") ";
}
string matrix::info() {
    string ret="matrix("+to_string(rows)+"*"+to_string(columns)+")\n(";
    try{
        for (int i = 1; i <= rows; i++) {
            for (int j = 1; j <= columns; j++) {
                ret+=to_string((*this)(i,j)) + " ";
            }
            if(i==rows) ret+=")";
            ret+= "\n";
        }   
        return ret;
    } 
    catch(exception *e)
    {
        throw runtime_error("cannot covert type "+to_string(*(typeid(element_type).name()))+" to string.");
    }
}
biginteger matrix::calculate_relpos(biginteger i, biginteger j){
    return sizeof(element_type)*((i-1)*columns+(j-1));
}
bool matrix::check_pos(biginteger i, biginteger j){
    return (1<=i && i<=rows) &&(1<=j && j<=columns);
}
bool matrix::check_multipliable(matrix &m){
    return columns==m.rows;
}
bool matrix::is_same_size(matrix &m){
    return rows==m.get_rows() and columns==m.get_columns();
}
matrix matrix::t(){
    matrix<element_type> ret(columns,rows);
    for(biginteger i=1;i<=rows;i++){
        for(biginteger j=1;j<=columns;j++){
            ret(i,j)=(*this)(j,i);
        }
    }
    return ret;
}

I don't know why compiler says that matrix class is not defined.

[Why should I not `#include `?](https://stackoverflow.com/questions/31816095/why-should-i-not-include-bits-stdc-h) [Why is “using namespace std;” considered bad practice?](https://stackoverflow.com/questions/1452721/why-is-using-namespace-std-considered-bad-practice) — 463035818_is_not_an_ai, Dec 10 '22 at 11:16
tip: Don't write alll the code at once and compile when you are done. Instead write tiny amounts of code, then compile, only write more when there are no errors or warnings. You do not need >15 methods to see that this is wrong, 1 would have been enough — 463035818_is_not_an_ai, Dec 10 '22 at 11:18
the duplicate is not about your current compiler error, but about the one you get next — 463035818_is_not_an_ai, Dec 10 '22 at 11:19
Thank you for the answer. but why the compile error isn't shown in public method and operation overloading? — being addicted to coding, Dec 10 '22 at 14:02

name list does not include my class name error

0 Answers0