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

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

Восстановить пароль Регистрация
Другие темы раздела
C++ Динамическое распределение памяти в функции и его возврат http://www.cyberforum.ru/cpp-beginners/thread448663.html
Обычно в курсах изложен вопрос о передаче 1- или 2-мерного массива в функцию. Не менее важно иногда вернуть результат в вызывающую программу. Что, неужели всегда надо выделять память для такого массива до передачи в функцию? код #include <iostream> #include <conio> void vvod(int **a , int n , int m) { a=new int*;
C++ Как это сделать ? [c++] Вот допустим у меня есть функция inline void fun(char* аргумент1, char *аргумент2) и есть 2 функция fun("аргумент1 ", переменая1); вопрос: http://www.cyberforum.ru/cpp-beginners/thread448654.html
C++ Рассчитать стоимость квартиры
Квадратный метр площади в строящемся доме, стоит 270 у.е. (курс НБУ). Стоимость квартиры С определяется по формуле: С=ВК*П*К, где ВК - стоимость 1 кв. метра площади, П - площадь квартиры, К - коэффициент, алгоритм определения которого следующий: 1-3 или 13-14 этажа - К = 1; 4-7 этажи - К = 2,5; 8-9 этажи - К = 1, 8; 10-12 этажи - К = 1,5. Рассчитать стоимость квартиры (в гривнях), если известны...
составить программу для вычисления функции C++
функция \begin{cases} & \text {lg}^{3} x+{x}^{2}\\ & \text \sqrt{x+t}+1/x \\ & \text cosx+t{sin}^{2}x \end{cases} Условие |x|>a |x|=a |x|<a Начальные данные
C++ Преобразование информции из текстового файла в двумерный массив http://www.cyberforum.ru/cpp-beginners/thread448650.html
Есть такая задачка В visual studio 2008 на С++ нужно рассчитать кратчайший путь от точки к точке в лабиринте. Лабиринт задается в текстовом файле, где ####- границы, пробелы - свободные клетки, а буквы А и В - начало и конец соответственно. Кратчайший путь заполняется точками. Хочу применить волновой алгоритм, но в текстовом файле... Вот и главный вопрос: если я могу в горизонтальной строке...
C++ Рандом растет srand(time(0)); int j=rand()%1000; char s="afasfa"; switch (message) /* handle the messages */ { case WM_DESTROY: {PostQuitMessage (0); KillTimer(hwnd,ID_TIMER); } /* send a WM_QUIT to the message queue */ break; case WM_TIMER: подробнее

Показать сообщение отдельно
Mr.X
Эксперт С++
 Аватар для Mr.X
2799 / 1575 / 246
Регистрация: 03.05.2010
Сообщений: 3,656
19.02.2012, 14:12     Классы с++.
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;
    }
}
 
Текущее время: 02:31. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru