Библиотека STL

@Ljubushkina · Регистрация: 25.09.2015

Студворк — интернет-сервис помощи студентам

Добрый вечер, очень нуждаюсь в Вашей помощи. Пропустила тему и теперь не успеваю в ней раобраться..
Помогите пожалуйста переписать код ниже в код и использованием библиотек STL

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
#pragma once
#include <iostream>
using namespace std;
 
template<class Type>
class matrix
{
private:
    Type** mat;
    unsigned int size_of_lines;
    unsigned int size_of_columns;
public:
    matrix(); //конструктор по умолчанию 
    matrix(int, int); //конструктор с двумя аргументами 
    matrix(matrix<Type>&); //конструктор копирования 
    ~matrix(); //деструктор 
    bool check_empty() const; //проверка на пустоту матрицы 
    int get_total_lines() const; //возвращает количество строк 
    int get_total_columns() const; //возвращает количество столбцов 
    void add_not_null_element(Type); //прибавляет не нулевой элемент 
    Type get_element(int, int); //возвращает найденный элемент по индексу 
    void show_matrix() const; //выводит матрицу в поток 
    void operator=(matrix<Type>&); //оператор присваивания 
};

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
#include "matrix.h"
 
template<class Type>
matrix<Type>::matrix()
{
    int j;
    mat = new Type*[size_of_lines];
 
    for (j = 0; j < size_of_lines; j++)
        mat[j] = new Type[size_of_columns];
 
    for (j = 0; j < size_of_lines; j++)
        for (int i = 0; i < size_of_columns; i++)
            mat[j][i] = NULL;
}
//---------------------------------------------------------------------------------------------
template<class Type>
matrix<Type>::matrix(int line_size, int column_size) :
size_of_lines(line_size), size_of_columns(column_size), mat(0)
{
    int j;
    mat = new Type*[size_of_lines];
 
    for (j = 0; j < size_of_lines; j++)
        mat[j] = new Type[size_of_columns];
 
    for (j = 0; j < size_of_lines; j++)
        for (int i = 0; i < size_of_columns; i++)
            mat[j][i] = 0 + rand() % 2;
}
//---------------------------------------------------------------------------------------------
template<class Type> 
matrix<Type>::matrix(matrix<Type>& temp) :
size_of_lines(temp.size_of_lines), size_of_columns(temp.size_of_columns)
{
    int j;
    mat = new Type*[temp.get_total_lines()];
 
    for (j = 0; j < temp.get_total_lines(); j++)
        mat[j] = new Type[temp.get_total_columns()];
 
    for (j = 0; j < temp.get_total_lines(); j++)
        for (int i = 0; i < temp.get_total_columns(); i++)
            mat[j][i] = temp.mat[j][i];
    cout << "\nКонструктор копирования успешно выполнен.\n\n";
}
//--------------------------------------------------------------------------------------------
template<class Type>
matrix<Type>::~matrix()
{
    for (int j = 0; j < size_of_lines; j++)
        delete mat[j];
    delete[]mat;
}
//--------------------------------------------------------------------------------------------
template<class Type>
void matrix<Type>::show_matrix() const
{
    for (int j = 0; j < size_of_lines; j++)
    {
        for (int k = 0; k < size_of_columns; k++)
            cout << mat[j][k] << ' ';
        cout << endl << endl;
    }
}
//---------------------------------------------------------------------------------------------
template<class Type>
void matrix<Type>::operator=(matrix<Type>& temp)
{
    size_of_lines = temp.size_of_lines;
    size_of_columns = temp.size_of_columns;
    if (check_empty() == true) //Если матрица пустая, то создаём копию матрицы из аргумента
    {
        int j;
        mat = new Type*[size_of_lines + 1];
 
        for (j = 0; j < size_of_lines; j++)
            mat[j] = new Type[size_of_columns];
 
        for (j = 0; j < size_of_lines; j++)
            for (int i = 0; i < size_of_columns; i++)
                mat[j][i] = temp.mat[j][i];
    }
    else
    {
        int j;
        for (j = 0; j < size_of_lines; j++)
            delete mat[j];
        delete []mat;
 
        mat = new Type*[size_of_lines + 1];
 
        for (j = 0; j < size_of_lines; j++)
            mat[j] = new Type[size_of_columns];
 
        for (j = 0; j < size_of_lines; j++)
            for (int i = 0; i < size_of_columns; i++)
                mat[j][i] = temp.mat[j][i];
    }
    cout << "\nОператор присваивания успешно выполнен.\n\n";
}
//---------------------------------------------------------------------------------------------
template<class Type>
bool matrix<Type>::check_empty() const
{
    for (int j = 0; j < size_of_lines; j++)
        for (int k = 0; k < size_of_columns; k++)
        {
            if (mat[j][k] != NULL)
                return false;
        }
    return true;
}
//-----------------------------------------------------------------------------------------------
template<class Type>
int matrix<Type>::get_total_lines() const
{
    return size_of_lines;
}
//------------------------------------------------------------------------------------------------
template<class Type>
int matrix<Type>::get_total_columns() const
{
    return size_of_columns;
}
//------------------------------------------------------------------------------------------------
template<class Type>
void matrix<Type>::add_not_null_element(Type x)
{
    for (int j = 0; j < size_of_lines; j++)
        for (int k = 0; k < size_of_columns; k++)
        {
            if (mat[j][k] == NULL)
            {
                mat[j][k] = x;
                break;
            }
        }
}
//--------------------------------------------------------------------------------------------------
template<class Type>
Type matrix<Type>::get_element(int ind1, int ind2)
{
    return mat[ind1][ind2];
}

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
#include "matrix.h"
#include "matrix.cpp"
#include <iostream>
using namespace std;
///////////////////////////////////////////////////////////////////////
 
template<class Type>
class matrix;
int main()
 
{
    setlocale(LC_ALL, "Russian");
    matrix< int > m1(5,5); //создаём 2 матрицы
    matrix< int > m2(5,5);
    matrix< int > m3(m1); //тестируем конструктор копирования
    m1.show_matrix(); //показываем первую
    cout << endl << endl;
 
    m2.show_matrix(); // показываем вторую
    cout << endl << endl;
 
    m3.show_matrix(); //выводим результат конструктора копирования
    cout << endl << endl;
 
    m3 = m2; //тестируем перегруженный оператор присваивания
 
    m3.show_matrix();
    m3.add_not_null_element(4); //прибавление не нулевого элемента
    cout << endl << endl;
    m3.show_matrix();
    cout << endl << endl;
    cout << m3.get_element(1, 1); //возвращаем выбранный элемент
    cout << endl << endl;
    system("pause");
    return 0;
}

Буду очень рада, если Вы поможете..

@Mr.X · 06.12.2015, 11:51

matrix.h

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
#pragma once
#include <iostream>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////// 
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////// 
template< class   T_elem >
class T_matrix
{
    //-------------------------------------------------------------------------
    typedef     std::vector     < T_elem    >   T_row;
    typedef     std::vector     < T_row     >   T_matr_val;
    typedef     size_t                          T_ind;
    //-------------------------------------------------------------------------
    T_matr_val      matr_val_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_matrix                            ( T_ind,    T_ind                   );          
    T_matrix                            ( T_matrix< T_elem >    const   &   );  
    //-------------------------------------------------------------------------
    bool        all_elements_are_zero   ()                                      const;                      
    T_ind       get_rows_total          ()                                      const;                      
    //-------------------------------------------------------------------------
    T_ind       get_columns_total       ()                                      const; 
 
    void        in_each_row_replace_first_zero_elem_to_element  ( T_elem );  
 
    T_elem  &   get_element             ( T_ind,    T_ind   ); 
    T_elem      get_element             ( T_ind,    T_ind   )                   const; 
    //-------------------------------------------------------------------------
    void        print_with_comment      ( T_str             const   &   comment     )   const;
    void        operator=               ( T_matrix<T_elem>  const   &               );
    void        reset                   ();
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    T_matr_val  get_zeroed_matr_val()   const;
    //-------------------------------------------------------------------------
};

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
#include "matrix.h"
#include <algorithm>
#include <cstdlib>
#include <iterator>
///////////////////////////////////////////////////////////////////////////////
template< class T_elem >
T_matrix< T_elem >::T_matrix
    (
        T_ind   rows_total      =   1, 
        T_ind   columns_total   =   1
    ) 
    :
    matr_val_   ( 
                    T_matr_val
                        ( 
                            rows_total,
                            T_row( columns_total ) 
                        ) 
                )
{
    std::for_each
        (
            matr_val_.begin     (),
            matr_val_.end       (),
 
            []                  ( auto  &   row )
            {
                std::generate
                    (
                        row.begin   (),
                        row.end     (),
 
                        []  
                        {
                            return  rand() % 2;
                        }
                    );
            }
        );
}
///////////////////////////////////////////////////////////////////////////////
template< class T_elem > 
T_matrix< T_elem >::T_matrix    ( T_matrix< T_elem >    const   &   matr_arg ) 
    :
    matr_val_( matr_arg.matr_val_ )
{}
///////////////////////////////////////////////////////////////////////////////
template< class T_elem >
void    T_matrix< T_elem >::print_with_comment
    ( T_str     const   &   comment )   const
{
    std::cout   <<  comment
                <<  std::endl;
 
    std::for_each
        (
            matr_val_.begin     (),
            matr_val_.end       (),
 
            []                  ( auto  const   &   row )
            {
                std::copy
                    (
                        row.begin                           (),
                        row.end                             (),
                        std::ostream_iterator< T_elem >     ( std::cout,    "\t" )
                    );
 
                std::cout   <<  std::endl;
            }
        );
 
    std::cout   <<  std::endl
                <<  std::endl;
}
///////////////////////////////////////////////////////////////////////////////
template< class T_elem >
void    T_matrix< T_elem >::operator=
    ( T_matrix< T_elem >    const   &   matr_arg )
{
    matr_val_   =   matr_arg.matr_val_;
 
    std::cout   <<  "Оператор присваивания успешно выполнен."
                <<  std::endl;
}
///////////////////////////////////////////////////////////////////////////////
template< class T_elem >
bool    T_matrix< T_elem >::all_elements_are_zero()     const
{
    return      matr_val_.empty                         ()
            ||  matr_val_.front().empty                 ()
            ||  matr_val_   ==  get_zeroed_matr_val     ();
}
///////////////////////////////////////////////////////////////////////////////
template< class T_elem >
typename    T_matrix< T_elem >::T_ind  
T_matrix< T_elem >::get_rows_total  ()  const
{
    return  matr_val_.size();
}
///////////////////////////////////////////////////////////////////////////////
template< class T_elem >
typename    T_matrix< T_elem >::T_ind   
T_matrix<T_elem>::get_columns_total     ()  const
{
    return  matr_val_.empty()
                ?   0
                :   matr_val_.front().size();
}
///////////////////////////////////////////////////////////////////////////////
template< class T_elem >
void    T_matrix< T_elem >::in_each_row_replace_first_zero_elem_to_element
    ( T_elem    elem )
{
    std::for_each
        (
            matr_val_.begin     (),
            matr_val_.end       (),
 
            [=]                 ( auto  &   row )
            {
                auto    it  =   std::find
                                    (
                                        row.begin   (),
                                        row.end     (),
                                        0
                                    );
 
                if  (
                        it  !=  row.end()
                    )
                {
                    *it     =   elem;
                }//if
            }
        );
}
///////////////////////////////////////////////////////////////////////////////
template< class T_elem >
T_elem  &   T_matrix< T_elem >::get_element
    ( 
        T_ind   row,
        T_ind   col
    )
{
    return      matr_val_.at( row ).at( col );  
}
///////////////////////////////////////////////////////////////////////////////
template< class T_elem >
T_elem  T_matrix< T_elem >::get_element
    ( 
        T_ind   row,
        T_ind   col
    )                   const
{
    return  matr_val_.at( row ).at( col );  
}
///////////////////////////////////////////////////////////////////////////////
template< class T_elem >
void    T_matrix< T_elem >::reset   ()
{
    matr_val_   =   get_zeroed_matr_val();
}
///////////////////////////////////////////////////////////////////////////////
template< class T_elem >
typename    T_matrix< T_elem >::T_matr_val
T_matrix< T_elem >::get_zeroed_matr_val()   const
{
    return  T_matr_val
                ( 
                    get_rows_total(),
 
                    T_row   ( 
                                get_columns_total()
                            ) 
                );
}
///////////////////////////////////////////////////////////////////////////////

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
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
#include "matrix.h"
#include "matrix.cpp"
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <stdexcept>
///////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
 
    T_matrix< int >     m1  (4,5);
    m1.print_with_comment   ( "m1" );
 
    std::cout   <<  "Матрица m1 "
 
                <<  (
                        m1.all_elements_are_zero()
                            ?   "нулевая."
                            :   "ненулевая."
                    )
 
                <<  std::endl;
 
    std::cout   <<  "В матрице m1 "
                <<  m1.get_rows_total()
                <<  " строк и "
                <<  m1.get_columns_total()
                <<  " столбцов."
                <<  std::endl;
                
    T_matrix< int >     m2  (5, 4);
    m2.print_with_comment   ( "m2" );
 
    const   T_matrix< int >     m3  (m1); 
    m3.print_with_comment   ( "Константная матрица m3 скопирована с m1." );
 
 
    std::cout   <<  "Элемент (1, 1) константной матрицы m3:"    
                <<  std::endl
                <<  m3.get_element(1, 1)
                <<  std::endl;
    try
    {
        std::cout   <<  "Элемент (1000, 1000) константной матрицы m3:"    
                    <<  std::endl
                    <<  m3.get_element(1000, 1000)
                    <<  std::endl;
    }
    catch( std::out_of_range    const   &   e )
    {
        std::cout   <<  "Выход индекса в функции get_element за допустимые пределы."
                    <<  std::endl;
    }
 
    m1 = m2; 
    m1.print_with_comment   ( "m1 получена присваиванием m2." );
    m1.in_each_row_replace_first_zero_elem_to_element   (4);
 
    m1.print_with_comment   ( 
                                "m1, в которой в каждой строке"
                                " первый нулевой элемент заменен на 4." 
                            );
 
    m2.get_element(1, 1)    =   1000;
 
    m2.print_with_comment
        ( "Матрица m2 с присвоенным элементу (1,1) значением 1000." );
 
    m2.reset();
    m2.print_with_comment( "Обнуленная матрица m2." );
 
    std::cout   <<  "Матрица m2 "
 
                <<  (
                        m2.all_elements_are_zero()
                            ?   "нулевая."
                            :   "ненулевая."
                    )
 
                <<  std::endl;
 
    T_matrix< int >     m4  (0, 0);
    m4.print_with_comment( "Матрица m4 с нулевым количеством строк и столбцов." );
 
    std::cout   <<  "Матрица m4 "
 
                <<  (
                        m4.all_elements_are_zero()
                            ?   "нулевая."
                            :   "ненулевая."
                    )
 
                <<  std::endl;
 
    std::cout   <<  "В матрице m4 "
                <<  m4.get_rows_total()
                <<  " строк и "
                <<  m4.get_columns_total()
                <<  " столбцов."
                <<  std::endl;
 
    m4.in_each_row_replace_first_zero_elem_to_element   (4);
 
    try
    {
        std::cout   <<  "Элемент (1, 1) матрицы m4:"    
                    <<  std::endl
                    <<  m4.get_element(1, 1)
                    <<  std::endl;
    }
    catch( std::out_of_range    const   &   e )
    {
        std::cout   <<  "Выход индекса в функции get_element за допустимые пределы."
                    <<  std::endl;
    }
 
    try
    {
        m4.get_element(1, 1)    =   1000;
    }
    catch( std::out_of_range    const   &   e )
    {
        std::cout   <<  "Выход индекса в функции get_element за допустимые пределы."
                    <<  std::endl;
    }
 
    m4.print_with_comment
        ( "Матрица m4 с присвоенным элементу (1, 1) значением 1000." );
 
    m4.reset();
 
    system("pause");
}

@Melg · 06.12.2015, 11:59

Ljubushkina,
Извольте.
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
#include <iostream>
 
#include "matrix.h"
 
using std::cout;
using std::endl;
 
void SetRussianLocale() { setlocale(LC_ALL, "Russian"); }
 
int main() {
  SetRussianLocale();
  matrix<int> m1(5, 5);
  matrix<int> m2(5, 5);
  matrix<int> m3(m1);
  cout << m1 << endl << endl;
  cout << m2 << endl << endl;
  cout << m3 << endl << endl;
 
  m3 = m2;
  cout << m3 << endl << endl;
 
  m3.add_not_null_element(1, 1, 4);
  cout << m3 << endl << endl;
 
  cout << m3.get_element(1, 1) << endl;
  cout << "Матрица м3 пуста: " << (m3.is_empty() ? "да" : "нет");
}

matrix.h:

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
#ifndef MATRIX_H
#define MATRIX_H
 
#include <vector>
#include <ostream>
 
using std::vector;
using std::ostream;
 
template <class T>
struct element {
  size_t number_of_row;
  size_t number_of_column;
  T value;
};
 
template <class T>
bool operator<(const element<T>& first, const element<T>& second) {
  if (first.number_of_row == second.number_of_row) {
    return first.number_of_column < second.number_of_column;
  } else {
    return first.number_of_row < second.number_of_row;
  }
}
 
template <class T>
class matrix {
 public:
  matrix() = default;
  matrix(size_t line_size, size_t column_size);
  matrix(const matrix<T>& oth);
  matrix<T>& operator=(const matrix<T>& oth);
 
  template <typename R>
  friend ostream& operator<<(ostream& out, const matrix<R>& m);
 
  bool is_empty() const;
  size_t get_total_lines() const;
  size_t get_total_columns() const;
 
  void add_not_null_element(size_t number_of_line, size_t number_of_column,
                            T element);
  T get_element(size_t number_of_line, size_t number_of_column) const;
 
 private:
  void add_element(const element<T>& element);
 
  size_t size_of_lines = 0;
  size_t size_of_columns = 0;
  vector<element<T> > elements;
};
 
template <class T>
ostream& operator<<(ostream& out, const matrix<T>& m);
 
#include "matrix_impl.h"
 
#endif  // MATRIX_H

matrix_impl.h:

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
#ifndef MATRIX_IMPL_H
#define MATRIX_IMPL_H
 
#include <algorithm>
 
using std::cout;
using std::endl;
using std::lower_bound;
 
template <class T>
matrix<T>::matrix(size_t line_size, size_t column_size)
    : size_of_lines(line_size), size_of_columns(column_size) {
  for (size_t j = 0; j < size_of_lines; ++j) {
    for (size_t i = 0; i < size_of_columns; ++i) {
      add_element({j, i, 0 + rand() % 2});
    }
  }
  cout << "\nКонструктор с аргументами успешно выполнен.\n\n";
}
 
template <class T>
matrix<T>::matrix(const matrix<T>& oth)
    : size_of_lines(oth.size_of_lines),
      size_of_columns(oth.size_of_columns),
      elements(oth.elements) {
  cout << "\nКонструктор копирования успешно выполнен.\n\n";
}
 
template <class T>
matrix<T>& matrix<T>::operator=(const matrix<T>& oth) {
  if (this != &oth) {
    size_of_lines = oth.size_of_lines;
    size_of_columns = oth.size_of_columns;
    elements = oth.elements;
  }
  cout << "\nОператор присваивания успешно выполнен.\n\n";
  return *this;
}
 
template <class T>
void matrix<T>::add_element(const element<T>& element) {
  if (element.value != T()) {
    auto position = lower_bound(elements.begin(), elements.end(), element);
    elements.insert(position, element);
  }
}
 
template <class T>
ostream& operator<<(ostream& out, const matrix<T>& m) {
  for (size_t j = 0; j < m.size_of_lines; ++j) {
    for (size_t k = 0; k < m.size_of_columns; ++k) {
      out << m.get_element(j, k) << ' ';
    }
    out << endl << endl;
  }
  return out;
}
 
template <class T>
bool matrix<T>::is_empty() const {
  return elements.empty();
}
 
template <class T>
size_t matrix<T>::get_total_lines() const {
  return size_of_lines;
}
 
template <class T>
size_t matrix<T>::get_total_columns() const {
  return size_of_columns;
}
 
template <class T>
void matrix<T>::add_not_null_element(size_t number_of_line,
                                     size_t number_of_column, T element) {
  add_element({number_of_line, number_of_column, element});
}
 
template <class T>
T matrix<T>::get_element(size_t number_of_line, size_t number_of_column) const {
  element<T> elem{number_of_line, number_of_column, T()};
  if (number_of_line < size_of_lines && number_of_column < size_of_columns) {
    auto elem_pos = lower_bound(elements.begin(), elements.end(), elem);
    if (elem_pos != elements.end() && !(elem < *elem_pos)) {
      return elem_pos->value;
    }
  }
 
  return elem.value;
}
 
#endif  // MATRIX_IMPL_H

Новые блоги и статьи Все статьи Все блоги /
PhpStorm 2025.3: WSL Terminal всегда стартует в ~ and_y87 14.12.2025 PhpStorm 2025. 3: WSL Terminal всегда стартует в ~ (home), игнорируя директорию проекта Симптом: После обновления до PhpStorm 2025. 3 встроенный терминал WSL открывается в домашней директории. . .	Access VikBal 11.12.2025 Помогите пожалуйста !! Как объединить 2 одинаковые БД Access с разными данными.	Новый ноутбук volvo 07.12.2025 Всем привет. По скидке в "черную пятницу" взял себе новый ноутбук Lenovo ThinkBook 16 G7 на Амазоне: Ryzen 5 7533HS 64 Gb DDR5 1Tb NVMe 16" Full HD Display Win11 Pro	Музыка, написанная Искусственным Интеллектом volvo 04.12.2025 Всем привет. Некоторое время назад меня заинтересовало, что уже умеет ИИ в плане написания музыки для песен, и, собственно, исполнения этих самых песен. Стихов у нас много, уже вышли 4 книги, еще 3. . .	От async/await к виртуальным потокам в Python IndentationError 23.11.2025 Армин Ронахер поставил под сомнение async/ await. Создатель Flask заявляет: цветные функции - провал, виртуальные потоки - решение. Не threading-динозавры, а новое поколение лёгких потоков. Откат?. . .
Поиск "дружественных имён" СОМ портов Argus19 22.11.2025 Поиск "дружественных имён" СОМ портов На странице: https:/ / norseev. ru/ 2018/ 01/ 04/ comportlist_windows/ нашёл схожую тему. Там приведён код на С++, который показывает только имена СОМ портов, типа,. . .	Сколько Государство потратило денег на меня, обеспечивая инсулином. Programma_Boinc 20.11.2025 Сколько Государство потратило денег на меня, обеспечивая инсулином. Вот решила сделать интересный приблизительный подсчет, сколько государство потратило на меня денег на покупку инсулинов. . . .	Ломающие изменения в C#.NStar Alpha Etyuhibosecyu 20.11.2025 Уже можно не только тестировать, но и пользоваться C#. NStar - писать оконные приложения, содержащие надписи, кнопки, текстовые поля и даже изображения, например, моя игра "Три в ряд" написана на этом. . .	Мысли в слух kumehtar 18.11.2025 Кстати, совсем недавно имел разговор на тему медитаций с людьми. И обнаружил, что они вообще не понимают что такое медитация и зачем она нужна. Самые базовые вещи. Для них это - когда просто люди. . .	Создание Single Page Application на фреймах krapotkin 16.11.2025 Статья исключительно для начинающих. Подходы оригинальностью не блещут. В век Веб все очень привыкли к дизайну Single-Page-Application . Быстренько разберем подход "на фреймах". Мы делаем одну. . .