Форум программистов, компьютерный форум CyberForum.ru

Перегрузка оператора << - C++

Восстановить пароль Регистрация
 
nocl1p
37 / 22 / 10
Регистрация: 30.03.2012
Сообщений: 299
25.06.2014, 11:25     Перегрузка оператора << #1
Как вот в таком классе перегрузить оператор <<?

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#ifndef MATRIXX_H
#define MATRIXX_H
 
#include <iostream>
 
using namespace std;
 
template<typename T>
class Matrix
{   
public:
//======================================================================================================
    Matrix<T>(int Row, int Col)
    {
        RowCount = Row; ColCount = Col;
        Array = new T *[RowCount];
        for (int index = 0; index < RowCount; index++)
            Array[index] = new T [ColCount];
 
        int index1 = 0, index2 = 0;
        for(index1 = 0; index1 < RowCount; index1++)
            for(index2 = 0; index2 < ColCount; index2++) 
                Array[index1][index2] = 0;
    }
//======================================================================================================
    ~Matrix<T>()
    {
        for(int index = 0; index < RowCount; index++)
            delete[] Array[index];
        delete[] Array;
        cout << "Destructor....";
        _getch();
    }
//======================================================================================================
    const Matrix<T> & operator = (const Matrix<T> & newM)
    {
        if (&newM == this)
            return *this;
 
        for (int index = 0; index < RowCount; index++)
            delete [] Array[index];
        delete [] Array;
 
        RowCount = newM.RowCount;
        ColCount = newM.ColCount;
 
        Array = new T[RowCount];
        for(int index = 0; index < RowCount; index++)
            Array[index] = new T[ColCount];
 
        for (int i = 0; i < RowCount; j++)
            for (int j = 0; j < ColCount; j++)
                Array[i][j] = newM.Array[i][j];
        return *this;
    }
//======================================================================================================
    Matrix<T>(const Matrix<T> & r)
    {
        RowCount = r.RowCount;
        ColCount = r.ColCount;
 
        Array = new T[RowCount];
        for(int index = 0; index < RowCount; index++)
            Array[index] = new T[ColCount];
 
        for (int i = 0; i < RowCount; j++)
            for (int j = 0; j < ColCount; j++)
                Array[i][j] = r.Array[i][j];
    }
//======================================================================================================
    friend ostream &operator << (ostream &outs, Matrix<T> &OutMatrix);
    ostream &operator << (ostream &outs, Matrix<T> &OutMatrix)
    {
 
    }
//======================================================================================================
    T operator ()(int IND1, int IND2)
    {
        return Array[IND1][IND2];
    }
//======================================================================================================
 
//======================================================================================================
    void SetIdentity()
    {
        if (RowCount == ColCount)
        {
            int IND1, IND2;
            for (IND1 = 0; IND1 < RowCount; IND1++)
                for (IND2 = 0; IND2 < RowCount; IND2++)
                {
                    Array[IND1][IND2] = 0;
                    Array[IND2][IND2] = 1;
                }
        }
    }
//======================================================================================================
    void Transpose()
    {
        int newRowCount = ColCount, newColCount = RowCount;
        // Создаем вспомогательный массив
        T **Arr = new T *[newColCount];
        for (int i = 0; i < newColCount; i++)
        {
            Arr[i] = new T[newRowCount];
            // Присваиваем строки массива Array столбцам массива Arr
            for (int j = 0; j < newColCount; j++)
                Arr[i][j] = Array[j][i];
        }
        // Освобождаем память Array
        for(int index = 0; index < RowCount; index++)
            delete[] Array[index];
        delete[] Array;
        // Присваиваем Arr
        Array = Arr;
        ColCount = newColCount;
        RowCount = newRowCount;
    }
//======================================================================================================
private:
    int RowCount, ColCount;
    T **Array;
};
 
#endif
Очень интересно... один параметр меня не устраивает та и любого другого адеквата не устроил бы. А в таком варивнте, как я представил, пишет много параметров. В шаблонах нельзя же вроде как в разных файлах определять и реализовывать класс.
Лучшие ответы (1)
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
25.06.2014, 11:25     Перегрузка оператора <<
Посмотрите здесь:

C++ Перегрузка оператора %
Перегрузка оператора == C++
Перегрузка оператора C++
перегрузка оператора! C++
Перегрузка оператора C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
zss
Модератор
Эксперт С++
 Аватар для zss
5942 / 5547 / 1783
Регистрация: 18.12.2011
Сообщений: 14,155
Завершенные тесты: 1
25.06.2014, 11:30     Перегрузка оператора << #2
Сообщение было отмечено автором темы, экспертом или модератором как ответ
71-75 строки
C++
1
2
3
4
5
6
7
8
9
10
11
template<class T2>
friend ostream &operator << (ostream &outs, Matrix<T2> &OutMatrix)
{
   for(int i=0;i<OutMatrix.RowCount;i++)
   {
       for(int j=0;j<OutMatrix.ColCount;j++)
            outs<<OutMatrix.Array[i][j]<<" ";
       outs<<endl;
   }
    return outs;
}
Функция не является членом класса Matrix
aLarman
636 / 557 / 89
Регистрация: 13.12.2012
Сообщений: 2,109
25.06.2014, 11:35     Перегрузка оператора << #3
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
template<typename T>
class Matrix
{   
public:
    //======================================================================================================
    Matrix<T>(int Row, int Col)
    {
        RowCount = Row; ColCount = Col;
        Array = new T *[RowCount];
        for (int index = 0; index < RowCount; index++)
            Array[index] = new T [ColCount];
 
        int index1 = 0, index2 = 0;
        for(index1 = 0; index1 < RowCount; index1++)
            for(index2 = 0; index2 < ColCount; index2++) 
                Array[index1][index2] = 0;
    }
    //======================================================================================================
    ~Matrix<T>()
    {
        for(int index = 0; index < RowCount; index++)
            delete[] Array[index];
        delete[] Array;
        cout << "Destructor....";
    }
    //======================================================================================================
    const Matrix<T> & operator = (const Matrix<T> & newM)
    {
        if (&newM == this)
            return *this;
 
        for (int index = 0; index < RowCount; index++)
            delete [] Array[index];
        delete [] Array;
 
        RowCount = newM.RowCount;
        ColCount = newM.ColCount;
 
        Array = new T[RowCount];
        for(int index = 0; index < RowCount; index++)
            Array[index] = new T[ColCount];
 
        for (int i = 0; i < RowCount; j++)
            for (int j = 0; j < ColCount; j++)
                Array[i][j] = newM.Array[i][j];
        return *this;
    }
    //======================================================================================================
    Matrix<T>(const Matrix<T> & r)
    {
        RowCount = r.RowCount;
        ColCount = r.ColCount;
 
        Array = new T[RowCount];
        for(int index = 0; index < RowCount; index++)
            Array[index] = new T[ColCount];
 
        for (int i = 0; i < RowCount; j++)
            for (int j = 0; j < ColCount; j++)
                Array[i][j] = r.Array[i][j];
    }
    //======================================================================================================
    friend ostream &operator << (ostream &outs, Matrix<T> &OutMatrix)
    {
//вывод
        return outs;
    }
    //======================================================================================================
    T operator ()(int IND1, int IND2)
    {
        return Array[IND1][IND2];
    }
    //======================================================================================================
 
    //======================================================================================================
    void SetIdentity()
    {
        if (RowCount == ColCount)
        {
            int IND1, IND2;
            for (IND1 = 0; IND1 < RowCount; IND1++)
                for (IND2 = 0; IND2 < RowCount; IND2++)
                {
                    Array[IND1][IND2] = 0;
                    Array[IND2][IND2] = 1;
                }
        }
    }
    //======================================================================================================
    void Transpose()
    {
        int newRowCount = ColCount, newColCount = RowCount;
        // Создаем вспомогательный массив
        T **Arr = new T *[newColCount];
        for (int i = 0; i < newColCount; i++)
        {
            Arr[i] = new T[newRowCount];
            // Присваиваем строки массива Array столбцам массива Arr
            for (int j = 0; j < newColCount; j++)
                Arr[i][j] = Array[j][i];
        }
        // Освобождаем память Array
        for(int index = 0; index < RowCount; index++)
            delete[] Array[index];
        delete[] Array;
        // Присваиваем Arr
        Array = Arr;
        ColCount = newColCount;
        RowCount = newRowCount;
    }
    //======================================================================================================
private:
    int RowCount, ColCount;
    T **Array;
};
работает же

Добавлено через 2 минуты
zss, вроде же так работает тока что проверил
C++
1
2
3
4
5
6
7
8
9
10
11
12
friend ostream &operator << (ostream &outs, Matrix<T> &OutMatrix)
    {
        for(int index1 = 0; index1 < OutMatrix.RowCount; index1++)
        {
            for(int index2 = 0; index2 < OutMatrix.ColCount; index2++) 
            {
                outs<<OutMatrix.Array[index1][index2];
            }
            outs<<endl;
        }
        return outs;
    }
Добавлено через 1 минуту
zss, без доп.параметра
zss
Модератор
Эксперт С++
 Аватар для zss
5942 / 5547 / 1783
Регистрация: 18.12.2011
Сообщений: 14,155
Завершенные тесты: 1
25.06.2014, 11:37     Перегрузка оператора << #4
Цитата Сообщение от aLarman Посмотреть сообщение
вроде же так работает
Если оставить так, то да, но если вздумаете реализацию вынести наружу объявления класса,
то придется оставить внутри такое объявление:
C++
1
2
template<class T2>
friend ostream &operator << (ostream &outs, Matrix<T2> &OutMatrix);
aLarman
25.06.2014, 11:38
  #5

Не по теме:

zss, аа вот в чем фишка, надо запомнить

nocl1p
37 / 22 / 10
Регистрация: 30.03.2012
Сообщений: 299
25.06.2014, 11:53  [ТС]     Перегрузка оператора << #6
Спасибо, ребят. Я этого прикола не знал((
Yandex
Объявления
25.06.2014, 11:53     Перегрузка оператора <<
Ответ Создать тему
Опции темы

Текущее время: 21:56. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru