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

Классы с++. - C++

Восстановить пароль Регистрация
 
Тина_Ливингстон
0 / 0 / 0
Регистрация: 01.11.2011
Сообщений: 59
19.02.2012, 01:03     Классы с++. #1
Фунты, шиллинги и пенсы
Старая английская денежная система использует три единицы для хранения денежных величин: фунты, шиллинги и пенсы. Один фунт (pound) состоит из 20 шиллингов, 1 шиллинг (shilling) – из 12 пенсов (penny, pence). Самая маленькая монета («фартинг») равняется четверти пенса, поэтому все расчеты требуется вести с точностью до ¼ пенса. Требуется создать класс для хранения информации о наличии денег в этой денежной системе. Сумма денег может быть только неотрицательной. Максимальная хранимая величина – 1 млрд. фунтов.
Предусмотреть наличие следующих методов:
• конструктора, получающего в качестве параметра неотрицательную сумму денег в фунтах, шиллингах и пенсах. При этом генерировать исключения, если
o – задается неверное количество шиллингов или пенсов,
o – превышена максимально хранимая величина;
o – отрицательная сумма.
• конструктора по умолчанию, задающего нулевую сумму денег;
• конструктора копирования;
• оператора присваивания;
• унарный -
• операций +, -, +=, -=,
• в этих арифметических операциях предусмотреть
переполнение или отрицательный результат – генерировать исключение
• сравнения (достаточно ==, <).
• вывода на консоль денежных сумм. Возможные форматы вывода (pd., sh., p. – сокращения соответственно для фунтов, шиллингов и пенсов):

2pd.
3pd.5sh.
6sh.3,5p.
5p.
10pd.2p.
-2pd.
-3pd.5sh.
-6sh.3,5p.
-5p.
-10pd.2p.

0p.

Код класса нужно оформить в виде двух файлов: заголовочного файла с объявлением класса и файла реализации.
Для демонстрации возможностей класса необходимо написать программу (отдельный файл), последовательно демонстрирующую все перечисленные методы.
Лучшие ответы (1)
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
19.02.2012, 01:03     Классы с++.
Посмотрите здесь:

Классы возможностей(Mixin классы) C++
C++ классы/дочерние классы/методы
C++ Динамические массивы структур;Классы. Класс массивы структур;Классы. Класс динамического массива структур.
Наследование, базовые классы и производные классы C++
Непонятна тема (Классы содержащие другие классы, как данные члены ) C++
Классы, включающие другие классы C++
Программа по классам, которая использует классы точек и прямых на плоскости, а, возможно, и другие классы C++
Классы и наследование (Создать класс 3D фигура, и производные классы шар, конус, цилиндр и куб. Создать функцию вычисления объёма.) C++

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

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
miriganua
129 / 100 / 4
Регистрация: 05.02.2012
Сообщений: 241
19.02.2012, 03:02     Классы с++. #2
Тина_Ливингстон, я попытался написать код, следуя условию задания. В его правильности не уверен, ведь сам только начал(1 курс) учить С++, хотя я его проверил, втоде правильно. Сделал все задания кроме унарного -(не знаю что имеется в виду). Не стал писать программу для тестирования, считаю, что лучше вам это сделать самим, по пути разберетесь в моих каракулях и может найдете ошибки. Код:

заголовочный файл с объявлением класса (у меня "classEnglishMoney.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
#ifndef classEnglishMoney_h
#define classEnglishMoney_h
 
class EnglishMoney
{
    //классы для обработки исключений
    class BadData { };
private:
    int pound;
    int shilling;
    int pence;
public:
    //конструктор
    EnglishMoney(int countOfPound, int countOfShilling, int countOfPence);
    //конструктора по умолчанию
    EnglishMoney();
    //конструктора копирования
    EnglishMoney(const EnglishMoney& money);
 
 
    //проверка в операторах
    void checkResult();
 
 
    //распределение после
    void distributionAfter();
    //распределение до
    void distributionBefore();
 
    
    //оператора присваивания
    EnglishMoney& operator=(const EnglishMoney& money);
    //операция +=
    EnglishMoney& operator+=(const EnglishMoney& money);
    //операция -=
    EnglishMoney& EnglishMoney::operator-=(const EnglishMoney& money);
    
    
    //операция +
    EnglishMoney operator+(const EnglishMoney& money);
    //операция -
    EnglishMoney operator-(const EnglishMoney& money);
    
 
    //оператор ==
    bool operator==(const EnglishMoney& money);
    //оператор <
    bool operator<(const EnglishMoney& money);
 
 
    //вывод на консоль денежной суммы
    void showMoney();
};
 
#endif

файл реализации (у меня "classEnglishMoney.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
#include <iostream>
#include "classEnglishMoney.h"
 
//конструктор
EnglishMoney::EnglishMoney(int countOfPound, int countOfShilling, int countOfPence)
{
    if (countOfPound < 0 || countOfShilling < 0 || countOfPence < 0 || countOfPound > 1000000000 || countOfShilling > 20 || countOfPence > 12)
    {
        throw BadData();
    }
    pound = countOfPound;
    shilling = countOfShilling;
    pence = countOfPence;
}
//конструктора по умолчанию
EnglishMoney::EnglishMoney()
{
    pound = 0;
    shilling = 0;
    pence = 0;
}
//конструктора копирования
EnglishMoney::EnglishMoney(const EnglishMoney& money)
{
    pound = money.pound;
    shilling = money.shilling;
    pence = money.pence;
}
 
 
//проверка в операторах
void EnglishMoney::checkResult()
{
    if (pound < 0 || shilling < 0 || pence < 0 || pound > 1000000000 || shilling > 20 || pence > 12)
    {
        throw BadData();
    }
}
 
 
//распределение после
void EnglishMoney::distributionAfter()
{
    if (pence >= 12)
    {
        pence = pence % 12;
        shilling++;
    }
    if (shilling >= 20)
    {
        shilling = shilling % 20;
        pound++;
    }
}
//распределение до
void EnglishMoney::distributionBefore()
{
    if (pound != 0)
    {
        pound--;
        shilling += 20;
    }
    if (shilling != 0)
    {
        shilling--;
        pence += 12;
    }
}
 
 
//оператора присваивания
EnglishMoney& EnglishMoney::operator=(const EnglishMoney& money)
{
    pound = money.pound;
    shilling = money.shilling;
    pence = money.pence;
    return *this;
}
//операция +=
EnglishMoney& EnglishMoney::operator+=(const EnglishMoney& money)
{
    pound += money.pound;
    shilling += money.shilling;
    pence += money.pence;
    distributionAfter();
    checkResult();
    return *this;
}
//операция -=
EnglishMoney& EnglishMoney::operator-=(const EnglishMoney& money)
{
    distributionBefore();
    pound -= money.pound;
    shilling -= money.shilling;
    pence -= money.pence;
    distributionAfter();
    checkResult();
    return *this;
}
 
 
//операция +
EnglishMoney EnglishMoney::operator+(const EnglishMoney& money)
{
    EnglishMoney newMoney;
    newMoney.pound = pound + money.pound;
    newMoney.shilling = shilling + money.shilling;
    newMoney.pence = pence + money.pence;
    newMoney.distributionAfter();
    newMoney.checkResult();
    return newMoney;
}
//операция -
EnglishMoney EnglishMoney::operator-(const EnglishMoney& money)
{
    EnglishMoney newMoney;
    distributionBefore();
    newMoney.pound = pound - money.pound;
    newMoney.shilling = shilling - money.shilling;
    newMoney.pence = pence - money.pence;
    distributionAfter();
    newMoney.distributionAfter();
    newMoney.checkResult();
    return newMoney;
}
 
 
 
//оператор ==
bool EnglishMoney::operator==(const EnglishMoney& money)
{
    if(pound != money.pound || shilling != money.shilling || pence != money.pence)
    {
        return false;
    }
    return true;
}
//оператор <
bool EnglishMoney::operator<(const EnglishMoney& money)
{
    if(pound < money.pound)
    {
        return true;
    }
    if(pound == money.pound && shilling < money.shilling)
    {
        return true;
    }
    if(pound == money.pound && shilling == money.shilling && pence < money.pence)
    {
        return true;
    }
    return false;
}
 
 
//вывод на консоль денежной суммы
void EnglishMoney::showMoney()
{
    std::cout << pound << "pd." << shilling << "sh." << pence << "p.";
}

файл программы, только наброски (у меня "Testing of the class.cpp")
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include "classEnglishMoney.h"
 
int main()
{
    try
    {
        EnglishMoney a1;
        EnglishMoney a2(1, 10, 5);
        EnglishMoney a4(2, 10, 4);
        EnglishMoney a3(a2);
        (a2 - a4).showMoney();
        return 0;
    }
    catch(EnglishMoney::BadData)
    {
        std::cout << "Programm obtains bad data. Programm stops. Try to check programm." << '\n';
    }
}
Возникнут вопросы пишите.
Mr.X
Эксперт С++
 Аватар для Mr.X
2807 / 1583 / 248
Регистрация: 03.05.2010
Сообщений: 3,695
19.02.2012, 14:12     Классы с++. #3
Сообщение было отмечено автором темы, экспертом или модератором как ответ
T_pounds.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
#pragma once
/////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
/////////////////////////////////////////////////////////////////////////////////////////
typedef long long       T_int;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_pounds
{
    static const T_int  SHILLINGS_PER_POUND     =   20;
    static const T_int  PENCE_PER_SHILLING      =   12;
    static const T_int  FARTHINGS_PER_PENNY     =   4;
 
    static const T_int  POUNDS_TOTAL_MAX        =   1000000000;
 
    static const T_int  FARTHINGS_TOTAL_MAX     =       FARTHINGS_PER_PENNY
                                                    *   PENCE_PER_SHILLING
                                                    *   SHILLINGS_PER_POUND
                                                    *   POUNDS_TOTAL_MAX;
    //-----------------------------------------------------------------------------------
    T_int   farthings_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------    
    T_pounds
        (
            T_int   pounds      = 0,
            T_int   shillings   = 0,
            T_int   pence       = 0
        );
    //-----------------------------------------------------------------------------------
    T_pounds                (const T_pounds&  pounds);
    //-----------------------------------------------------------------------------------
    T_pounds&   operator=   (const T_pounds&  pounds);
    T_pounds    operator-   ()                          const;
    T_pounds&   operator+=  (const T_pounds&  pounds);
    T_pounds&   operator-=  (const T_pounds&  pounds);
    T_pounds    operator+   (const T_pounds&  pounds)   const;
    T_pounds    operator-   (const T_pounds&  pounds)   const;
    bool        operator==  (const T_pounds&  pounds)   const;
    bool        operator<   (const T_pounds&  pounds)   const;
    //-----------------------------------------------------------------------------------
    friend  std::ostream& operator<<
        (
            std::ostream&   os, 
            T_pounds        p
        );
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void  check_farthings_value()                       const;
    //-----------------------------------------------------------------------------------
    static T_int  get_farthings
        (
            T_int   pounds,
            T_int   shillings,
            T_int   pence
        );
    //-----------------------------------------------------------------------------------
    void  get_pd_sh_p
            (                
                T_int&  pounds,
                T_int&  shillings,
                T_int&  pence
            )                                           const;
    //-----------------------------------------------------------------------------------
};

T_pounds.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
/////////////////////////////////////////////////////////////////////////////////////////
#include "T_pounds.h"
#include <stdexcept>
/////////////////////////////////////////////////////////////////////////////////////////
T_pounds::T_pounds
    (
        T_int   pounds,
        T_int   shillings,
        T_int   pence
    )
    :
    farthings_  (
                    get_farthings
                        (
                            pounds,
                            shillings,
                            pence
                        )
                ) 
{
    check_farthings_value();
 
    T_int   new_pounds      = 0;
    T_int   new_shillings   = 0;
    T_int   new_pence       = 0;
 
    get_pd_sh_p
        (
            new_pounds,
            new_shillings,
            new_pence
        );
 
    if(
            new_pounds      !=  pounds
        ||  new_shillings   !=  shillings
        ||  new_pence       !=  pence
      )
    {
        throw   std::invalid_argument("Invalid pounds or shillings or pence value.");
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
T_pounds::T_pounds(const T_pounds&  pounds)
    :
    farthings_( pounds.farthings_ )
{}
/////////////////////////////////////////////////////////////////////////////////////////
T_pounds&   T_pounds::operator= (const T_pounds&  pounds)
{
    farthings_  =   pounds.farthings_;
    return  *this;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_pounds  T_pounds::operator- () const
{
    T_pounds  res;
    res.farthings_  =   -farthings_;
    return  res;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_pounds&  T_pounds::operator+= (const T_pounds&  pounds)
{
    farthings_  +=  pounds.farthings_;
    check_farthings_value();
    return  *this;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_pounds&  T_pounds::operator-= (const T_pounds&  pounds)
{
    return  operator+=(-pounds);
}
/////////////////////////////////////////////////////////////////////////////////////////
T_pounds  T_pounds::operator+ (const T_pounds&  pounds)   const
{
    T_pounds  res(*this);
    return  res +=  pounds;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_pounds  T_pounds::operator- (const T_pounds&  pounds)   const
{
    return  operator+(-pounds);
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_pounds::operator== (const T_pounds&  pounds)      const
{
    return  farthings_ == pounds.farthings_;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_pounds::operator< (const T_pounds&  pounds)       const
{
    return  farthings_ < pounds.farthings_;
}
/////////////////////////////////////////////////////////////////////////////////////////
std::ostream& operator<<
    (
        std::ostream&   os, 
        T_pounds        p
    )
{
    if( p < 0 )
    {
        os  <<  "-";
        p   =   -p;
    }
 
    T_int   pounds      = 0;
    T_int   shillings   = 0;
    T_int   pence       = 0;
 
    p.get_pd_sh_p
        (                
            pounds,
            shillings,
            pence
        );
 
    if( pounds )
    {
        os  <<  pounds
            <<  "pd.";
    }
 
    if( shillings )
    {
        os  <<  shillings
            <<  "sh.";
    }
 
    if(
                !pounds
            &&  !shillings
        ||  pence 
      )
    {
        os  <<  pence
            <<  "p.";
    }
 
    return os;
}
/////////////////////////////////////////////////////////////////////////////////////////
void  T_pounds::check_farthings_value()   const
{
    if( farthings_ < 0 )
    {
        throw   std::range_error("Negative value.");
    }
 
    if( farthings_ > FARTHINGS_TOTAL_MAX )
    {
        throw   std::range_error("Too great value.");
    }    
}
/////////////////////////////////////////////////////////////////////////////////////////
T_int  T_pounds::get_farthings
    (
        T_int   pounds,
        T_int   shillings,
        T_int   pence
    )
{
    return      FARTHINGS_PER_PENNY 
            *   (
                        pence
                    +   (
                                PENCE_PER_SHILLING
                            *   (
                                        shillings
                                    +       SHILLINGS_PER_POUND
                                        *   pounds
                                )
                        )
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
void  T_pounds::get_pd_sh_p
        (                
            T_int&  pounds,
            T_int&  shillings,
            T_int&  pence
        )   const
{
    pence       =   farthings_  /   FARTHINGS_PER_PENNY;
 
    shillings   =   pence       /   PENCE_PER_SHILLING;
    pence       =   pence       %   PENCE_PER_SHILLING;
 
    pounds      =   shillings   /   SHILLINGS_PER_POUND;
    shillings   =   shillings   %   SHILLINGS_PER_POUND;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_pounds_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
/////////////////////////////////////////////////////////////////////////////////////////
#include "T_pounds.h"
#include <iomanip>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
T_int  input_money( const T_str&    prompt )
{
    const int   FIELD_WIDTH     =   15;
    std::cout   <<  std::setw( FIELD_WIDTH )
                <<  prompt
                <<  ": ";
 
    T_int   res;
    std::cin    >>  res;
    return  res;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_pounds  input_pd_sh_p( const T_str&    prompt )
{
    std::cout   <<  prompt
                <<  ":"
                <<  std::endl;
 
    T_int   pd  =   input_money( "фунты"    );
    T_int   sh  =   input_money( "шиллинги" );
    T_int   p   =   input_money( "пенсы"    );
 
    return  T_pounds
                (
                    pd,
                    sh,
                    p
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
 
    std::cout   <<  "Тестирование конструктора, оператора присваивания и оператора унарного минуса."
                <<  std::endl;
 
    try
    {
        T_pounds    pounds  =   input_pd_sh_p( "Введите сумму в фунтах, шиллингах и пенсах" );
 
        std::cout   <<  std::endl
                    <<  "Введенное значение с минусом: "
                    <<  -pounds
                    <<  std::endl;
    }
    catch( std::exception&  e )
    {
        std::cout   <<  e.what()
                    <<  std::endl;
    }
 
    std::cout   <<  std::endl
                <<  std::endl
                <<  "Тестирование операций +, -, +=, -= и операций сравнения ==, <."
                <<  std::endl;
 
    try
    {
        T_pounds    L   =   input_pd_sh_p( "Введите левый операнд" );
        std::cout   <<  std::endl;
 
        T_pounds    R   =   input_pd_sh_p( "Введите правый операнд" );
        std::cout   <<  std::endl;
 
        if( L == R )
        {
            std::cout   <<  "L == R"
                        <<  std::endl;
        }
        else if( L < R )
        {
            std::cout   <<  "L < R"
                        <<  std::endl;    
        }
        else
        {
            std::cout   <<  "L > R"
                        <<  std::endl;    
        }
 
        std::cout   <<  "L + R = ";
        std::cout   <<  (L + R)
                    <<  std::endl;
 
        std::cout   <<  "L - R = ";
        std::cout   <<  (L - R)
                    <<  std::endl;    
    }
    catch( std::exception&  e )
    {
        std::cout   <<  e.what()
                    <<  std::endl;
    }
}
Yandex
Объявления
19.02.2012, 14:12     Классы с++.
Ответ Создать тему
Опции темы

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