Форум программистов, компьютерный форум, киберфорум
Наши страницы

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
 
Рейтинг: Рейтинг темы: голосов - 19, средняя оценка - 4.68
andreyich
0 / 0 / 0
Регистрация: 08.08.2010
Сообщений: 16
#1

Размер матрицы - C++

24.08.2010, 01:26. Просмотров 3181. Ответов 39
Метки нет (Все метки)

Люди, помогите пожалуйста!

У меня есть задание: создать библиотеку функций для работы с матрицами.
Можно ли сделать ,так что в параметрах функций были только матрицы , а размеры их программа знала сама???

Объясните пожалуйста новичку! Заранее благодарен.
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
24.08.2010, 01:26
Я подобрал для вас темы с готовыми решениями и ответами на вопрос Размер матрицы (C++):

размер матрицы - C++
#include <iostream> #include <vector> #include <stack> using namespace std; typedef vector<int > T_vec; typedef...

Задать размер матрицы - C++
Здравствуйте. Хочу задать размер матрицы примерно вот так (так нельзя, естественно): #include <iostream> #include <string> #include...

Размер vs. размерность матрицы - C++
Вопрос скорее теоретический. Чем отличается размер матрицы от размерности? И как правильно спрашивать пользователя в программе: "Введите...

Найти среднее арифметическое элементов каждой строки матрицы Q (lm) и отнять его от элементов этой строки. размер матрицы 7х7.заранее спасибо - C++
Найти среднее арифметическое элементов каждой строки матрицы Q (lm) и отнять его от элементов этой строки.. размер матрицы 7х7.заранее...

Найти минимальный размер матрицы размером m x n - C++
Помогите, пожалуйста! Программа считывает размеры матрицы, рандомно генерирует значения ее членов и из них ищет минимальный. В 18-й...

Как задать размер матрицы в конструкторе класса? - C++
Подскажите как задать размер матрицы в конструкторе класса? Решаю задачи из учебника, не могу понять, думаю это невозможно... Р. Лафоре...

39
andreyich
0 / 0 / 0
Регистрация: 08.08.2010
Сообщений: 16
24.08.2010, 17:07  [ТС] #16
Вот когда с sizeof работаю в мэйне все норм, но когда ево использую в функциях постояно возвращает значение 0.
0
Nameless One
Эксперт С++
5783 / 3432 / 255
Регистрация: 08.02.2010
Сообщений: 7,448
24.08.2010, 17:11 #17
andreyich, покажи код
0
andreyich
0 / 0 / 0
Регистрация: 08.08.2010
Сообщений: 16
24.08.2010, 17:17  [ТС] #18
Цитата Сообщение от Nameless One Посмотреть сообщение
andreyich, покажи код
Это пример кода:

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
#include<conio.h>
#include<iostream.h>
int func(int **a);
 
main()
 {
  clrscr();
  int **a,d;
 
  a= new int* [3];
   for(int i=0;i<3;i++)
   {
     a[i]= new int [2];
   }
   d=func(a);
  cout<<d<<endl;
  getch();
  return 0;
 }
int func(int **a)
 {
  int l;
 
  l=sizeof(a);
 
  return l;
 }
И еще в функции пишет что 'а' не используется
0
Nameless One
Эксперт С++
5783 / 3432 / 255
Регистрация: 08.02.2010
Сообщений: 7,448
24.08.2010, 17:23 #19
andreyich, тебе же уже сказали, что sizeof'ом для определения размера массива можно только тогда, когда массив у тебя - статический.
Если ты работаешь с динамическими массивами, то:
  1. передавай размер массива как параметр функции;
  2. разработай классы для работы с матрицей, которые будут хранить могут хранить размер матриц
ИМХО, второй вариант лучше

PS. Могу поделиться своими классами, если надо.
0
easybudda
Модератор
Эксперт CЭксперт С++
9966 / 5889 / 996
Регистрация: 25.07.2009
Сообщений: 11,149
24.08.2010, 17:25 #20
Цитата Сообщение от andreyich Посмотреть сообщение
l=sizeof(a);
Цитата Сообщение от accept Посмотреть сообщение
получится sizeof(int *)
В Вашем случае sizeof(int**), что явно тоже не то, что требовалось...
0
Nameless One
Эксперт С++
5783 / 3432 / 255
Регистрация: 08.02.2010
Сообщений: 7,448
24.08.2010, 17:27 #21
Кстати, sizeof возвращает размер переменной (в твоем случае - массива) в байтах. Так что, чтобы узнать число элементов в массиве, нужно этот размер разделить на размер одного элемента. Но повторюсь, это сработает только для статических массивов.
0
andreyich
0 / 0 / 0
Регистрация: 08.08.2010
Сообщений: 16
24.08.2010, 17:30  [ТС] #22
Цитата Сообщение от Nameless One Посмотреть сообщение
andreyich, тебе же уже сказали, что sizeof'ом для определения размера массива можно только тогда, когда массив у тебя - статический.
Если ты работаешь с динамическими массивами, то:
  1. передавай размер массива как параметр функции;
  2. разработай классы для работы с матрицей, которые будут хранить могут хранить размер матриц
ИМХО, второй вариант лучше

PS. Могу поделиться своими классами, если надо.
Было бы хорошо поделится потому что у меня послезавтра сдача курсовой
0
Nameless One
Эксперт С++
5783 / 3432 / 255
Регистрация: 08.02.2010
Сообщений: 7,448
24.08.2010, 17:40 #23
Классы обеспечивают сложение и умножение матриц, умножение/деление матриц и векторов на число, умножение матриц на вектора, возведение матрицы в степень. Построение единичной и нулевой матриц заданных размеров.
Объявление и реализация классов:
vector.hpp
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
#ifndef VECTOR_HPP
#define VECTOR_HPP
 
#include <cstdlib>
 
namespace my
{
    class vector
    {
 
    public:
 
        vector(size_t size = 0);
        vector(double val, size_t size);
        vector(const vector& rhs);
        ~vector();
 
        void resize(size_t size); // Изменить размер вектора
        size_t size() const; // Размер вектора
 
        vector& operator = (const vector& rhs);
        double& operator [] (size_t index); // Доступ по индексу
 
        // Умножение на число (с обоих сторон)
        vector operator * (double val) const;
        friend vector operator * (double val, const vector& rhs);
 
        // Деление на число
        vector operator / (double val) const;
 
        double operator * (const vector& rhs) const; // Скалярное произведение
        vector operator + (const vector& rhs) const; // Сложение векторов
        vector operator - (const vector& rhs) const; // Вычитание векторов
 
        // Сравнение векторов
        bool operator == (const vector& rhs) const;
        bool operator != (const vector& rhs) const;
 
    private:
 
        size_t  m_nSize;
        double* m_pdVec;
    };
}
#endif // VECTOR_HPP

vector.cpp
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#include "vector.hpp"
 
#include <stdexcept>
 
namespace my
{
    vector::vector(size_t size)
        : m_nSize(size)
    {
        if(size)
            m_pdVec = new double[m_nSize]();
        else
            m_pdVec = NULL;
    }
 
    vector::vector(double val, size_t size)
        : m_nSize(size)
    {
        if(m_nSize)
        {
            m_pdVec = new double[m_nSize];
            for(size_t i = 0; i < m_nSize; ++i)
                m_pdVec[i] = val;
        }
        else
            m_pdVec = NULL;
    }
 
    vector::vector(const vector& rhs)
        : m_nSize(rhs.m_nSize)
    {
        if(m_nSize)
        {
            m_pdVec = new double[m_nSize];
            for(size_t i = 0; i < m_nSize; ++i)
                m_pdVec[i] = rhs.m_pdVec[i];
        }
        else
            m_pdVec = NULL;
    }
 
    vector::~vector()
    {
        if(m_nSize)
            delete[] m_pdVec;
    }
 
    void vector::resize(size_t size)
    {
        if(m_nSize == size)
            return;
        if(m_nSize)
            delete[] m_pdVec;
        m_nSize = size;
        m_pdVec = new double[m_nSize]();
    }
 
    size_t vector::size() const
    {
        return m_nSize;
    }
 
    vector& vector::operator = (const vector& rhs)
    {
        this->resize(rhs.m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            m_pdVec[i] = rhs.m_pdVec[i];
        return *this;
    }
 
    double& vector::operator [] (size_t index)
    {
        if(index >= m_nSize)
            throw(std::out_of_range("Vector: the index is out of range"));
        return m_pdVec[index];
    }
 
    vector vector::operator * (double val) const
    {
        vector temp(m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pdVec[i] = m_pdVec[i] * val;
        return temp;
    }
 
    vector operator * (double val, const vector& rhs)
    {
        vector temp(rhs.m_nSize);
        for(size_t i = 0; i < rhs.m_nSize; ++i)
            temp.m_pdVec[i] = rhs.m_pdVec[i] * val;
        return temp;
    }
 
    vector vector::operator / (double val) const
    {
        if(!val)
            throw(std::domain_error("Vector: dividing by zero"));
        vector temp(m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pdVec[i] = m_pdVec[i] / val;
        return temp;
    }
 
    double vector::operator * (const vector& rhs) const
    {
        if(m_nSize != rhs.m_nSize)
            throw(std::domain_error("Vector: incorrect dimensions"));
        double retval = 0;
        for(size_t i = 0; i < m_nSize; ++i)
            retval += m_pdVec[i] * rhs.m_pdVec[i];
        return retval;
    }
 
    vector vector::operator + (const vector& rhs) const
    {
        if(m_nSize != rhs.m_nSize)
            throw(std::domain_error("Vector: incorrect dimensions"));
        vector temp(m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pdVec[i] = m_pdVec[i] + rhs.m_pdVec[i];
        return temp;
    }
 
    vector vector::operator - (const vector& rhs) const
    {
        if(m_nSize != rhs.m_nSize)
            throw(std::domain_error("Vector: incorrect dimensions"));
        vector temp(m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pdVec[i] = m_pdVec[i] - rhs.m_pdVec[i];
        return temp;
    }
 
    bool vector::operator == (const vector& rhs) const
    {
        if(m_nSize != rhs.m_nSize)
            return false;
        for(size_t i = 0; i < m_nSize; ++i)
            if(m_pdVec[i] != rhs.m_pdVec[i])
                return false;
        return true;
    }
 
    bool vector::operator != (const vector& rhs) const
    {
        return !(*this == rhs);
    }
}

matrix.hpp
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
#ifndef MATRIX_HPP
#define MATRIX_HPP
 
#include "vector.hpp"
 
namespace my
{
    class matrix
    {
 
    public:
 
        matrix(size_t row, size_t col);
        matrix(double val, size_t row, size_t col);
        matrix(const matrix& rhs);
        ~matrix();
 
        void resize(size_t row, size_t col); // Изменить размер матрицы
        size_t rows() const; // Число строк
        size_t cols() const; // Число столбцов
 
        // Единичная и нулевая матрицы заданных размеров
        matrix E(size_t row, size_t col) const;
        matrix O(size_t row, size_t col) const;
 
        // Транспонирование матрицы
        matrix transpose() const;
 
        matrix& operator = (const matrix& rhs);
        vector& operator [] (size_t index); // Доступ по индексу
 
        // Умножение на число (с обоих сторон)
        matrix operator * (double val) const;
        friend matrix operator * (double val, const matrix& rhs);
 
        // Деление на число
        matrix operator / (double val) const;
 
        // Умножение на матрицы на вектор
        vector operator * (const vector& vec) const;
 
        // Умножение матриц
        matrix operator * (const matrix& rhs) const;
 
        // Возведение матрицы в степень (только для квадратных матриц!)
        matrix pow(size_t exp) const;
 
        // Сложение и вычитание матриц
        matrix operator + (const matrix& rhs) const;
        matrix operator - (const matrix& rhs) const;
 
        // Сравнение матриц
        bool operator == (const matrix& rhs) const;
        bool operator != (const matrix& rhs) const;
 
        //double determinant() const; // Определитель
        //matrix invertible() const; // Обратная матрица
 
    private:
 
        // "Быстрое" возведение в степень
        matrix fastpow(const matrix& base, size_t exp) const;
 
        size_t  m_nRow;
        size_t  m_nCol;
        vector* m_pvMatrix;
    };
}
 
#endif // MATRIX_HPP

matrix.cpp
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
#include "matrix.hpp"
 
#include <stdexcept>
 
namespace my
{
    matrix::matrix(size_t row, size_t col)
        : m_nRow(row), m_nCol(col)
    {
        if(m_nRow)
        {
            m_pvMatrix = new vector[m_nRow];
            for(size_t i = 0; i < m_nRow; ++i)
                m_pvMatrix[i] = vector(m_nCol);
        }
        else
            m_pvMatrix = NULL;
    }
 
    matrix::matrix(double val, size_t row, size_t col)
        : m_nRow(row), m_nCol(col)
    {
        if(m_nRow)
        {
            m_pvMatrix = new vector[m_nRow];
            for(size_t i = 0; i < m_nRow; ++i)
                m_pvMatrix[i] = vector(val, m_nCol);
        }
        else
            m_pvMatrix = NULL;
    }
 
    matrix::matrix(const matrix &rhs)
        : m_nRow(rhs.m_nRow), m_nCol(rhs.m_nCol)
    {
        if(m_nRow)
        {
            m_pvMatrix = new vector[m_nRow];
            for(size_t i = 0; i < m_nRow; ++i)
                m_pvMatrix[i] = rhs.m_pvMatrix[i];
        }
        else
            m_pvMatrix = NULL;
    }
 
    matrix::~matrix()
    {
        if(m_nRow)
            delete[] m_pvMatrix;
    }
 
    void matrix::resize(size_t row, size_t col)
    {
        if(row != m_nRow)
        {
            if(m_nRow)
                delete[] m_pvMatrix;
            m_nRow = row;
            m_pvMatrix = new vector[m_nRow];
        }
        for(size_t i = 0; i < m_nRow; ++i)
            m_pvMatrix[i].resize(col);
    }
 
    size_t matrix::rows() const
    {
        return m_nRow;
    }
 
    size_t matrix::cols() const
    {
        return m_nCol;
    }
 
    matrix matrix::E(size_t row, size_t col) const
    {
        matrix temp(row, col);
        for(size_t i = 0; i < row; ++i)
            temp.m_pvMatrix[i][i] = 1;
        return temp;
    }
 
    matrix matrix::O(size_t row, size_t col) const
    {
        return matrix(row, col);
    }
 
    matrix matrix::transpose() const
    {
        matrix temp(m_nCol, m_nRow);
        for(size_t i = 0; i < m_nRow; ++i)
            for(size_t j = 0; j < m_nCol; ++j)
                temp.m_pvMatrix[j][i] = m_pvMatrix[i][j];
        return temp;
    }
 
    matrix& matrix::operator = (const matrix& rhs)
    {
        this->resize(rhs.m_nRow, rhs.m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            m_pvMatrix[i] = rhs.m_pvMatrix[i];
        return *this;
    }
 
    vector& matrix::operator [] (size_t index)
    {
        if(index >= m_nRow)
            throw(std::out_of_range("Matrix: the index is out of range"));
        return m_pvMatrix[index];
    }
 
    matrix matrix::operator * (double val) const
    {
        matrix temp(m_nRow, m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            temp.m_pvMatrix[i] = m_pvMatrix[i] * val;
        return temp;
    }
 
    matrix operator * (double val, const matrix& rhs)
    {
        matrix temp(rhs.m_nRow, rhs.m_nCol);
        for(size_t i = 0; i < temp.m_nRow; ++i)
            temp.m_pvMatrix[i] = rhs.m_pvMatrix[i] * val;
        return temp;
    }
 
    matrix matrix::operator / (double val) const
    {
        if(!val)
            throw(std::domain_error("Matrix: dividing by zero"));
        matrix temp(m_nRow, m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            temp.m_pvMatrix[i] = m_pvMatrix[i] / val;
        return temp;
    }
 
    vector matrix::operator * (const vector& vec) const
    {
        if(m_nCol != vec.size())
            throw(std::domain_error("Matrix: incorrect dimensions"));
        vector temp(m_nRow);
        for(size_t i = 0; i < m_nRow; ++i)
            temp[i] = m_pvMatrix[i] * vec;
        return temp;
    }
 
    matrix matrix::operator * (const matrix& rhs) const
    {
        if(m_nCol != rhs.m_nRow)
            throw(std::domain_error("Matrix: incorrect dimensions"));
        matrix ret(m_nRow, rhs.m_nCol);
        matrix temp = rhs.transpose();
        for(size_t i = 0; i < m_nRow; ++i)
            for(size_t j = 0; j < rhs.m_nCol; ++j)
                ret.m_pvMatrix[i][j] = m_pvMatrix[i] * temp.m_pvMatrix[j];
        return ret;
    }
 
    matrix matrix::pow(size_t exp) const
    {
        if(m_nRow != m_nCol)
            throw(std::domain_error("Matrix: not square matrix"));
        return fastpow((*this), exp);
    }
 
    matrix matrix::fastpow(const matrix& base, size_t exp) const
    {
        if(!exp)
            return matrix::E(m_nRow, m_nCol);
        if(exp & 1)
            return base * fastpow(base, --exp);
        return fastpow(base, (exp / 2)) * fastpow(base, (exp / 2));
    }
 
    matrix matrix::operator + (const matrix& rhs) const
    {
        if((m_nRow != rhs.m_nRow) || (m_nCol != rhs.m_nCol))
            throw(std::domain_error("Matrix: incorrect dimensions"));
        matrix temp(m_nRow, m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            temp.m_pvMatrix[i] = m_pvMatrix[i] + rhs.m_pvMatrix[i];
        return temp;
    }
 
    matrix matrix::operator - (const matrix& rhs) const
    {
        if((m_nRow != rhs.m_nRow) || (m_nCol != rhs.m_nCol))
            throw(std::domain_error("Matrix: incorrect dimensions"));
        matrix temp(m_nRow, m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            temp.m_pvMatrix[i] = m_pvMatrix[i] - rhs.m_pvMatrix[i];
        return temp;
    }
 
    bool matrix::operator == (const matrix& rhs) const
    {
        if((m_nRow != rhs.m_nRow) || (m_nCol != rhs.m_nCol))
            return false;
        for(size_t i = 0; i < m_nRow; ++i)
            if(m_pvMatrix[i] != rhs.m_pvMatrix[i])
                return false;
        return true;
    }
 
    bool matrix::operator != (const matrix& rhs) const
    {
        return !(*this == rhs);
    }
}


Тестирование класса matrix:
main.cpp
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
#include <iostream>
#include <cstdlib>
#include <iomanip>
 
#include "matrix.hpp"
#include "vector.hpp"
 
#define boolDebug(EXP) std::cout << std::boolalpha << #EXP " : " \
    << (EXP) << std::endl
 
void printM(my::matrix& m, const char* name)
{
    std::cout << "Matrix \'" << name << "\':" << std::endl;
    for(size_t i = 0; i < m.rows(); ++i, std::cout << std::endl)
        for(size_t j = 0; j < m.cols(); ++j)
            std::cout << std::left << std::setw(8) << m[i][j];
}
 
void initM(my::matrix& m)
{
    for(size_t i = 0; i < m.rows(); ++i)
        for(size_t j = 0; j < m.cols(); ++j)
            m[i][j] = i + j + i * j;
}
 
int main()
{
    try
    {
        my::matrix m32(3, 2);
        initM(m32);
        printM(m32, "m32");
        my::matrix m23(2, 3);
        initM(m23);
        printM(m23, "m23");
        boolDebug(m23 == m32);
        boolDebug(m23 == m32.transpose());
        my::matrix m33 = m32 * m23;
        printM(m33, "m33");
        my::matrix check(3, 3);
        for(size_t i = 0, di = 1, dj = 2;
            i < check.rows(); ++i, di += 2, dj += 5)
            for(size_t j = 0, val = di; j < check.cols(); ++j, val += dj)
                check[i][j] = val;
        printM(check, "check");
        boolDebug(m33 == check);
        my::matrix m22(2, 2);
        initM(m22);
        printM(m22, "m22");
        my::matrix m22_pow5 = m22.pow(5);
        my::matrix pow5_check = m22 * m22 * m22 * m22 * m22;
        printM(pow5_check, "(m22)^5_check");
        printM(m22_pow5, "(m22)^5");
        boolDebug(m22_pow5 == pow5_check);
        my::matrix m22_plus = m22 + m22_pow5;
        my::matrix m22_minus = m22 - m22_pow5;
        printM(m22_plus, "m22_plus");
        printM(m22_minus, "m22_minus");
        my::matrix E33 = m22.E(3, 3);
        my::matrix E33_check = m33 * E33;
        printM(E33_check, "E33_check");
        boolDebug(m33 == E33_check);
    }
    catch(std::exception& e)
    {
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}


Вычисления определителя и обратной матрицы я делать не стал, но это добавить не трудно.
1
andreyich
0 / 0 / 0
Регистрация: 08.08.2010
Сообщений: 16
24.08.2010, 17:44  [ТС] #24
Большое человеческое спасибо!!!
Но у меня вопрос что это за разрешение 'hpp'?
Это как ''.H'' для С++?
0
Nameless One
Эксперт С++
5783 / 3432 / 255
Регистрация: 08.02.2010
Сообщений: 7,448
24.08.2010, 17:47 #25
andreyich, это один из форматов расширения для заголовочных файлов С++
0
andreyich
0 / 0 / 0
Регистрация: 08.08.2010
Сообщений: 16
24.08.2010, 18:23  [ТС] #26
Есть проблемка: не могу подключить файлы!
Напомните пожалуйста как правильно использовать #ifndef и #endif?
0
ForEveR
В астрале
Эксперт С++
7992 / 4751 / 321
Регистрация: 24.06.2010
Сообщений: 10,547
Завершенные тесты: 3
24.08.2010, 18:26 #27
andreyich,
C++
1
2
3
4
#ifndef _SOME_FILE_H_
#define _SOME_FILE_H_
//Some code
#endif
0
Nameless One
Эксперт С++
5783 / 3432 / 255
Регистрация: 08.02.2010
Сообщений: 7,448
24.08.2010, 18:27 #28
andreyich, эти директивы не отвечают непосредственно за подключение файла, они лишь препятствуют его повторному подключению. Тебе же нужно создать файлы с теми же именами и содержимым, которое я привел, и подключить их к проекту. Ничего менять, тем более директивы препроцессора, не надо.
0
andreyich
0 / 0 / 0
Регистрация: 08.08.2010
Сообщений: 16
24.08.2010, 18:30  [ТС] #29
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#ifndef  _MATRIX_HPP_
#define  _MATRIX_HPP_
 
class MATRIX
  {
    public:
      int detimtr(int **,int );
      double detdomtr(double **,int );
      int minimtr(int **,int ,int ,int );
      float minflomtr(float **,int ,int ,int );
      void sumimtr(int **,int **,int **,int ,int );
      void sumdomtr(double **,double **,double **,int ,int );
      void trimtr(int **,int **,int ,int );
      void trdomtr(double **,double **,int ,int );
      void dobiimtr(int **,int **,int ,int ,int );
      void dobdoimtr(double **,double **,int ,int ,int );
      void dobdodomtr(double **,double **,double ,int ,int );
      void rizimtr(int **,int **,int **,int ,int );
      void rizdomtr(double **,double **,double **,int ,int );
      void mnozhimtr(int **,int **,int **,int ,int ,int );
      void mnozhdomtr(double **,double **,double **,int ,int ,int );
  };
#endif
Подскажите где ошибка?
0
Nameless One
Эксперт С++
5783 / 3432 / 255
Регистрация: 08.02.2010
Сообщений: 7,448
24.08.2010, 18:32 #30
andreyich, так сразу и не скажешь. А в чем ошибка заключается?
Кстати, у тебя класс матрицы совсем не содержит переменных-членов? Конструкторов? Деструктора?
0
24.08.2010, 18:32
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
24.08.2010, 18:32
Привет! Вот еще темы с ответами:

помогите сделать: подпрограмма считывает размер матрицы из первого файла и передает его во второй? - C++
не могли бы вы подделиться ссылкой на пример,где подпрограмма считывает размер матрицы из первого файла и передает его во второй? заранее...

С клавиатуры вводится размер матрицы и сама матрица. Найти в матрице строку с максимальной суммой и отсортиров - C++
С клавиатуры вводится размер матрицы и сама матрица. Найти в матрице строку с максимальной суммой и отсортировать

Зачем при передаче матрицы в функцию, передавать вторым аргументом её размер, если в первом он уже указан? - C++
Добрый день господа.Объясните пожалуйста почему при вызове функции f() В левый индекс ничего не засовывается и для чего нужен правый...

Ввести размер массива с клавиатуры и передать этот размер в конструктор - C++
Я создал массив объектов. И я хочу ввести размер этого массива с клавиатуры, и передать этот размер в конструктор, как мне это сделать? ...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
30
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2018, vBulletin Solutions, Inc.
Рейтинг@Mail.ru