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

Массивы. Структурные типы. - C++

Восстановить пароль Регистрация
 
Selector_Al
0 / 0 / 0
Регистрация: 25.05.2011
Сообщений: 12
04.12.2011, 12:49     Массивы. Структурные типы. #1
Суть задачи: Написать программу, обрабатывающую рациональные дроби, хранящиеся в двумерном массиве (матрице). Каждая рациональная дробь определяется как пара (числитель, знаменатель).
На входе программы – две матрицы рациональных дробей (формат представления дробей нужно разработать самостоятельно).
Программа должна обеспечить загрузку двух матриц и вычисление их суммы.
В файл результатов нужно напечатать как исходные матрицы, так и результат вычислений.

Формат представления матриц в файле:
2 4 3 5 2 3
12 7 3 2 6 17
5 3 7 2 4 4
1 3 4 5 3 1
11 2 4 7 3 10
12 3 5 7 7 10

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
//используемые библиотеки:
#include "file.h"
#include "matrix.h"
#include <iostream>
#include <fstream>
using namespace std;
//---------------------------------------------------
 
int main(int argc, char** argv) //работаем через командную строку
{
    setlocale(LC_ALL, "RUS");
        //---------------------------------------------------
    if(argc<2)
    {
        cout<<"Входной файл не указан"<<endl;
        return 0;
    }
    if(argc==2)
    {
        argc++;
        argv[2]="output.txt";
    }
    if (strcmp(argv[1],argv[2])==0)
    {
        cout<<"Аргументы должны быть разными!"<<endl;
        return 0;
    }
 
 
    //определение общего количества элементов входного файла:
    int elemNum=countElemnts(argv[1]);
    int elemRows=countRows(argv[1]);
    int elemColum=elemNum/elemRows;
    cout<<"Количество столбцов: "<<elemColum<<endl;
 
    checkInFile(elemNum); //проверка считанных данных
    
    Matrix A(elemNum/2,elemRows/2,elemColum);
    Matrix B(elemNum/2,elemRows/2,elemColum);
    if ((!readMatrix(argv[1],A)) || (!readMatrix(argv[1],B)))
    {
        cout<<"Ошибка вывода элементов из файла"<<endl;
        return 0;
    }
    writeMatrix(argv[2],A);
    writeMatrix(argv[2],B);
    Matrix C(A+=B);
    writeMatrix(argv[2],C);
    //---------------------------------------------------
    system("PAUSE");
    return 0;
}
Добавлено через 34 секунды
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef _FILE_H
#define _FILE_H
 
//используемые библиотеки:
#include "elem.h"
#include <fstream>
//---------------------------------------------------
//прототипы ф-ий:
 
//подсчет количества элементов, строк и столюцов в файле
int countElemnts(const char* );
int countRows(const char* );
//проверки:
//проверка на существование элементов в файле
int checkInFile(int );
 
 
#endif
Добавлено через 22 секунды
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
//используемые библиотеки:
#include "file.h"
//---------------------------------------------------
 
//результат: количество элементов входного файла
int countElemnts(const char* fileName)
{
    ifstream in(fileName); //открытие потока
    if (!in.is_open()) //файл не открыт
    {
        cout<<"Файл не существует"<<endl;
        return 0;
    }
    Elem e;
    int i; //тут, т.к. нам нужно вернуть i в качестве результата ф-ии 
    for (i=0;;i++)
    {
        in>>e;
        if (in.fail())
            break;
    }
    cout<<"Количество элементов в файле: "<<i<<endl;
    in.close();
    return i;
}
 
int countRows(const char* fileName)
{
    ifstream in(fileName);
    if (!in.is_open()) //файл не открыт
    {
        cout<<"Файл не существует"<<endl;
        return 0;
    }
    char str[30]; int i=0;
    while (!in.eof())
    {
        in.getline(str, 30, '\n');
        i++;
    }
    cout<<"Количество строк в файле: "<<i<<endl;
    in.close();
    return i;
}
//ф-ии проверок файлов:
 
//результат: файл не содержит никаких элементов
int checkInFile(int elemNum)
{
    if (elemNum==0)
        cout<<"Отсутствие данных в файле"<<endl;
    return 0;
}
Добавлено через 15 секунд
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
#ifndef _ELEM_H
#define _ELEM_H
 
//используемые библиотеки:
#include <iostream>
#include <fstream>
using namespace std;
//---------------------------------------------------
 
struct Elem
{
    //числитель & знаменатель
    int numer, denom;
    //ф-ия сокращения дробей
    void simplify();
    
 
    Elem(); //конструктор "по умолчанию"
    //ввод элементов
    friend istream& operator >> (istream& , Elem& );
    //вывод элементов
    friend ostream& operator << (ostream& , const Elem& );
    //деление
    Elem& operator /= (const Elem& );
    
};
 
Elem operator + (const Elem& , const Elem& );
Elem& operator += (Elem& ,const Elem& );
int getNod(int , int );
 
#endif
Добавлено через 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
//используемые библиотеки:
#include "elem.h"
//---------------------------------------------------
Elem::Elem()
{
    numer=0;
    denom=1;
}
//---------------------------------------------------
istream& operator >> (istream& in, Elem& e)
{
    in>>e.numer>>e.denom;
    return in;
}
 
ostream& operator << (ostream& out, const Elem& e)
{
    out<<e.numer<<"/"<<e.denom;
    return out;
}
 
Elem& Elem::operator /= (const Elem& d)
{
   numer *= d.denom;
   denom *= d.numer;
   simplify();
   return *this;
}
 
Elem operator + (const Elem& e1, const Elem& e2)
{
    Elem a=e1;
    a+=e2;
    return a;
}
 
Elem& operator += (Elem& e1, const Elem& e2)
{
    if (e1.denom==e2.denom)
    {
        e1.numer=e1.numer+e2.numer;
        return e1;
    }
    else 
    {
        int i=getNod(e1.denom,e2.denom);
        if (i==1)
        {
            e1.denom=e1.denom*e2.denom;
            e1.numer=(e1.numer*e1.denom)+(e2.numer*e1.denom);
            return e1;
        }
        else 
        {
            e1.numer=(e1.numer*e2.denom)+(e2.numer*e1.denom);
            e1.denom=e1.denom*e2.denom;
            return e1;
        }
    }
}
 
//---------------------------------------------------
void Elem::simplify()
{
    if(denom<0)
    {
        numer=-numer;
        denom=-denom;
    }
    for(int i=2;i<=abs(denom) && i<=abs(numer);i++)
    {
        if(numer%i==0 && denom%i==0)
        {
            numer /= i;
            denom /= i;
            i--;
        }
    }
}
 
int getNod(int a, int b)
{
    while (a!=b)
    {
        if (a<b)
            b=b-a;
        else
            a=a-b;
    }
    return a;
}
Добавлено через 23 секунды
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
#ifndef _MATRIX_H
#define _MATRIX_H
 
//используемые библиотеки:
#include "elem.h"
//---------------------------------------------------
//прототипы ф-ий:
struct Matrix
{
    int amtElem, rows, columns;
    Elem** arrMatrix; //двумерный массив (матрица)
    //-----------------------------------------------
    Matrix(); //конструктор "по умолчанию"
    Matrix(int ,int ,int ); //конструктор с параметром (передается количество элементов)
    Matrix(const Matrix& ); //конструктор копирования (создает новый объект с параметрами старого)
    ~Matrix(); //деструктор!!!:)
    //-----------------------------------------------
    Matrix operator + (const Matrix& ) const;
    const Matrix& operator += (const Matrix& );
};
 
bool readMatrix(const char* ,Matrix& ); //ф-ия считывания элементов в матрицу
 
void createMatrix (Matrix &matrix, int rows, int columns, Elem e);
 
bool writeMatrix (const char* fileName, Matrix &matrix);
 
#endif
Добавлено через 38 секунд
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
//используемые библиотеки:
#include "matrix.h"
//---------------------------------------------------
Matrix::Matrix()
{
    amtElem=0;
    rows = 0;
    columns = 0;
    //arrMatrix = new Elem*[amtElem]; 
    //arrMatrix[0]=new Elem[amtElem]; 
    arrMatrix=0;
}
 
Matrix::Matrix(int elemNum, int elemRows, int elemColum)
{
    amtElem=elemNum;
    rows=elemRows;
    columns=elemColum;
 
    if (amtElem>0)
    {
        arrMatrix=new Elem* [amtElem];
        for (int i=0; i<amtElem; i++)
            arrMatrix[i]=new Elem[amtElem];
    }
    else arrMatrix=0;
}
 
Matrix::Matrix(const Matrix& origin)
{
    amtElem=origin.amtElem;
    rows=origin.rows;
    columns=origin.columns;
 
    if (amtElem>0)
    {
        arrMatrix=new Elem* [amtElem];
        for (int i=0; i<amtElem; i++)
        {
            arrMatrix[i]=new Elem[amtElem];
            arrMatrix[i]=origin.arrMatrix[i];
        }
    }
    else arrMatrix=0;
}
 
Matrix::~Matrix()
{
    for (int i=0; i<amtElem; i++)
        delete [] arrMatrix[i];
    delete [] arrMatrix; //
}
//---------------------------------------------------
// Перегруженный оператор сложения матриц, результат отдельно
Matrix Matrix::operator + (const Matrix &rhs) const
{
    Matrix result(*this); // Результирующая матрица, равна
                          // изначально первой матрице
 
    // Если количество строк и столбцов первой матрицы
    // совпадает с количеством соответственно строк и
    // столбцов второй матрицы
    if ((rows == rhs.rows) && (columns == rhs.columns))
    {
        Elem x;
        // Идём по строкам матрицы
        for (int i = 0; i < rows; ++i)
            // Идём по элементам очередной строки
            for (int j = 0; j < columns; ++j)
            {
                // Прибавляем к каждому элементу результируещей
                // матрицы (который изначально совпадает с
                // соответствующим элементом первой матрицы)
                // соответствующий элемент второй матрицы
                result.arrMatrix[i][j] += rhs.arrMatrix[i][j];
                x+=rhs.arrMatrix[i][j];
            }
 
    }
    // Если размеры левой и правой матриц не совпадают,
    // результатом операции сложения будет число 0
    //else
        //result.resize();
 
    // Возвращаем результирующую матрицу
    return result;
}
 
// Перегруженный оператор сложения матриц, результат в правой матрице
const Matrix& Matrix::operator += (const Matrix &rhs)
{
    // Сохраняем в правую матрицу результат
    // сложения правой и левой матриц посредством
    // перегруженной операции сложения матриц
    *this = *this + rhs;
 
    return *this;
}
 
bool readMatrix(const char* fileName, Matrix& matrix)
{
    ifstream in(fileName);
    if (!in.is_open())
        return 0;
    for (int rows=0; rows<matrix.rows; rows++)
    {
        for (int columns=0; columns<matrix.columns; columns++)
        {
            Elem e;
            in>>e;
            createMatrix(matrix, rows, columns, e);
        }
    }
    in.close();
    return true;
}
 
 
void createMatrix (Matrix &matrix, int rows, int columns, Elem e)
{
    matrix.arrMatrix [rows] [columns] = e;
}
 
bool writeMatrix (const char* fileName, Matrix &matrix)
{
    ofstream out(fileName);
    if (!out.is_open())
        return false;
    for (int rows=0; rows<matrix.rows; rows++)
        {
            for (int columns=0; columns<matrix.columns; columns++)
            {
                out<<matrix.arrMatrix [rows] [columns]<<" ";
            }
            out<<endl;
        }
    out.close();
    return true;
}
Добавлено через 2 минуты
проблема в считывании двух матриц из файла... не знаю как считать сначала три строки в одну из файла, а потом три следующие в другую.. поэтому тут делаю две одинаковые матрицы из первых трех строк.. и хотел их сложить, но вот не до конца понимаю что не так написал
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
04.12.2011, 12:49     Массивы. Структурные типы.
Посмотрите здесь:

C++ Структурные типы в Borland C
структурные переменные и обьеденения C++
C++ " Структуры, объединения и определяемые пользователем типы. Массивы структур"
C++ структурные данные
C++ Массивы. Структурные типы.
Структурированные типы данных. Массивы С++ C++
Типы данных: есть ли универсальный тип, который может заменить все типы данных в Си? C++
C++ Создать программу обработки массивов структур используя структурные переменные и переменные типа объеденения

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

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Ответ Создать тему
Опции темы

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