Перегрузка выходного потока для печати всей матрицы

Question

Я пытаюсь сделать < < вывод всей матрицы, на которую я написал шаблон. Не знаю, почему это не работает, ошибка:

error: no match for 'operator[]' (operand types are 'matrix<int' and 'int') 
candidate is: 
matrix<Comparable> matrix<Comparable>::operator[](matrix<Comparable>&) [with Comparable = int]| 
no known conversion for argument 1 from 'int' to 'matrix<int>&'| 

, который относится к этой линии: о < < RHS [I] [J]. Я должен перегружать [], а?

matrix.h:

template <typename Comparable> 
class matrix 
{ 
    private: 
     size_t num_cols_; 
     size_t num_rows_; 
     Comparable **array_; 

    public: 
     friend ostream& operator<< (ostream& o, const matrix<Comparable> & rhs); 
     size_t NumRows(); 
     size_t NumCols(); 
}; 

matrix.cpp:

template <typename Comparable> 
ostream& operator<< (ostream& o, matrix<Comparable> & rhs){ 
    size_t c = rhs.NumRows(); 
    size_t d = rhs.NumCols(); 
    for (int i = 0; i < c; i++){ 
     for (int j = 0; j < d; j++){ 
      o << rhs[i][j];   //error 
     } 
    } 
} 

template <typename Comparable> 
size_t matrix<Comparable>::NumRows(){ 
    return num_rows_; 
} 

template <typename Comparable> 
size_t matrix<Comparable>::NumCols(){ 
    return num_cols_; 
} 

И, вероятно, не имеет значения, но я реализовал матрицу так:

array_ = new Comparable*[num_rows_]; 
for (int i = 0; i < num_rows_; i++){ 
    array_[i] = new Comparable[num_cols_]; 

Answer 1

Ваши функции подписи не матч:

ostream& operator<< (ostream& o, const matrix<Comparable> & rhs); 

не

template <typename Comparable> 
ostream& operator<< (ostream& o, matrix<Comparable> & rhs); 

Обратите внимание, что один не шаблон, а другой. Кроме того, первый имеет аргумент const const для rhs, а второй имеет только ссылку. Это несоответствие означает, что функция вы определяете дружит не Matrix «S, и поэтому не может получить доступ к private (или protected членов Matrix)

Что вы хотите, чтобы объявить шаблонную функцию, а затем сообщить компилятору, что один экземпляр (например, ostream& operator<<(ostream& out, const matrix<int>& val)) - это единственная функция, с которой вы хотите дружить с matrix<int>.

Чтобы сделать это, вам нужно объявить, что вы хотите только определенную версию шаблона функции, и сделать что вам нужно объявить шаблон и сделать что вам нужно объявить шаблонный класс ,

В конце концов, что вся цепочка деклараций может выглядеть примерно так:

#include <iostream> 

// forward declare the class so the compiler knows what's up at the 
// templated operator<< declaration. 
template <typename T> 
class Foo; 

// forward declare the templated operator<< so the compiler knows you're 
// 'friend'ing a specific instantiation of this template in the 
// class definition. 
template <typename T> 
std::ostream& operator<<(std::ostream& out, const Foo<T>& value); 

template <typename T> 
class Foo{ 
    // declare the instantiation of the operator<< template that shares 
    // T with the class template to be a friend: 
    // operator<<<> can be separated out into operator<< <> 
    friend std::ostream& operator<<<>(std::ostream& out, const Foo<T>& value); 
    int bar_; 
public: 
    Foo(int bar) : bar_{bar}{} 
}; 

// now that you know the contents of `Foo<T>`, define the templated operator<< 
template <typename T> 
std::ostream& operator<<(std::ostream& out, const Foo<T>& value){ 
    return std::cout << "Foo: " << value.bar_; 
} 

int main(){ 
    Foo<int> 
     a{2}, 
     b{3}; 

    std::cout << a << '\n' << b; 

} 

Live on Coliru

Вы можете читать далее Шаблон друзей на C++ Super-FAQ.

Answer 2

Вы можете объявить функцию get для доступа к массиву вместо того, чтобы сделать его публичным членом;