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

Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" - C++

Восстановить пароль Регистрация
 
 
Рейтинг: Рейтинг темы: голосов - 621, средняя оценка - 4.99
Kimel
15 / 15 / 0
Регистрация: 01.02.2012
Сообщений: 182
01.02.2012, 17:47     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #1
Хотя я и начинающий с++-шник. Хочу помочь другим людям. Здесь я буду выкладывать всё что мне удалось решить. В моих решениях будет много хедеров, делал я это в Dev C++. Ос Win 7 64 bit.

Начнём со второй главы:
Упражнение 1
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream> 
 
using namespace std;
 
int main()
{
   setlocale(0,"Rus");
   float gallons, cufeet;
 
   cout << "Введите количество галоннов: \n";
   cin >> gallons;
   cufeet = gallons / 7.481;
   cout << "Еквивалент в футах = " << cufeet << endl;
    
   return 0;
}

Упражнение 2
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream> 
#include <iomanip>
 
using namespace std;
 
int main()
{
   setlocale(0,"Rus");
   
    cout << 1990 << setw(8) << 135 << endl
           << 1991 << setw(8) << 7290 << endl 
           << 1992 << setw(8) << 11300 << endl
           << 1993 << setw(8) << 16200 << endl;
  
   return 0;
}

Упражнение 3
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream> 
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    int var = 10;
 
    cout << var << endl;      
    var *= 2;                 
    cout << var-- << endl;    
    cout << var << endl;      
    return 0;
}

Упражнение 4
C++
1
2
3
4
5
6
7
8
9
10
#include <iostream> 
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    cout<<"\nУ лукоморья дуб срубили\nКота на мясо порубили \nА по неведанным дорожкам\nШагали черти в босоножках\n"; 
    return 0;
}

Упражнение 5
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream> 
#include <ctype.h>
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    char ch;
    cin >> ch;
    cout << islower(ch);  // При вводе строчной буквы будет 2 при прописной 0. Но есть нюанс, поддерживаються только англ буквы 
    return 0;
}


Упражнение 6
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream> 
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
 
    float a,b,c,d,f;
    cout << "Введите кол-во доларов"<<endl;
    cin >> f;
    b=f/1.487;
    c=f/0.172;
    a=f/0.584;
    d=f/0.00955;
    cout << f <<"доларов = "<< b<<" фунтов стерлинга"<<endl;
    cout << f <<"доларов = "<< c<<" франков"<<endl;
    cout << f <<"доларов = "<< a<<" немецких марок"<<endl;
    cout << f <<"доларов = "<< d<<" японских йен"<<endl;
    return 0;
}

Упражнение 7
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream> 
#include <iomanip>
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    double f,c;
    cout << "Введите количество градусов по Цельсию"<<endl;
    cin >> c;
    f=c*1.8+32;
    cout <<setprecision(3)<< f << " градусов по Фаренгейту "<< endl; // Регуляция кол-во символов после запятой
    return 0;
}

Упражнение 8
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream> 
#include <iomanip>
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    long pop1=2425785, pop2=47, pop3=9761;       
 
    cout << setfill('.') <<setw(8) << "LOCATION" << setw(12) // Обратите внимание на одинарные кавычки
           << "POPULATION" << endl
           <<setw(8) << "Portcity" << setw(12) << pop1 << endl
           << setw(8) << "Hightown" << setw(12) << pop2 << endl
           << setw(8) << "Lowville" << setw(12) << pop3 << endl;
    return 0;
}

Упражнение 9

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream> 
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    char dummychar;
    double a,b,c,d,e,f;
    cout << "Введите а и b"<< endl;
    cin >>a>>dummychar>>b;
    cout << "Введите c и d"<<endl;
    cin >>c>>dummychar>>d;
    cout <<(b*c)+(d*a)<<dummychar<<(b*d)<<endl;
 
    return 0;
}

Упражнение 10 (Намучился с этой задачей)
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream> 
 
using namespace std;
 
int main() 
{
    setlocale(0,"Rus");
    float a,b,c,f;
    cout << "Введите количество фунтов"<<endl;
    cin >> a;
    cout << "Введите количество шиллингов"<<endl;
    cin >> b;
    cout << "Введите количество пенсов"<<endl;
    cin >> c;
    f = a+(b+c/12)/20;
    cout << "Количество фунтов = " << f << endl;
    return 0;
}

Упражнение 11
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream> 
#include <iomanip>
 
using namespace std;
 
int main() 
{
     setlocale(0,"Rus");
     cout << setiosflags(ios::left) <<setw(15) << "Фамилия"<< setw(15)<< "Имя"<<setw(15) << "Адресс"<<setw(15)<< "Город"<<endl
            <<setw(15)<< "Иванов"<<setw(15)<<"Петя"<<setw(15)<<"Кленовая 16"<<setw(10)<<"Москва"<<endl
            <<setw(15)<< "Иванов"<<setw(15)<<"Петя"<<setw(15)<<"Кленовая 16"<<setw(10)<<"Москва"<<endl
            <<setw(15)<< "Иванов"<<setw(15)<<"Петя"<<setw(15)<<"Кленовая 16"<<setw(10)<<"Москва"<<endl;
    return 0;
}

Упражнение 12 (это самая геморная программа на разработку которой ушло больше дня)
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream> 
 
using namespace std;
 
int main() 
{
setlocale(0,"Rus");
float a,b,z;
int c,k;
cout << "Введите кол-во футов " << endl;
cin >> a;
c = static_cast<int>(a);
b = a - c;
b *= 20;
k = static_cast<int>(b);
z = b - k;
z = z*12;
z = static_cast<int>(z);
k = static_cast<int>(k);
cout << c <<"."<< k <<"."<< z << endl;
return 0;
}
Это конец второй главы, третюю сделаю позже если будет нужна
 Комментарий модератора 
Пост обновлен по просьбе ТС
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
01.02.2012, 17:47     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++"
Посмотрите здесь:

Объектно-ориентированное программирование C++
C++ Объектно-ориентированное программирование
C++ Объектно ориентированное программирование
Ищу ответы на задания из книги Лафоре Р. "Объектно-ориентированное программирование в С++" 4 издание. C++
C++ Объектно-ориентированное программирование C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
MacInsider
4 / 4 / 0
Регистрация: 09.08.2013
Сообщений: 30
26.08.2013, 19:37     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #81
Глава 15, упражнение 5:
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
#include "stdafx.h"
#include <iostream>
#include <algorithm>
#include <iterator>
#include <vector>
#include <set>
 
using namespace std;
const int MAX = 5;
 
int main() 
{
    setlocale(LC_CTYPE,"Russian");
 
    int arr1[MAX] = {2, 4, 6, 8, 10};
    int arr2[MAX] = {1, 3, 5, 7, 9};
    set<int> iSet(arr2, arr2 + 5);
 
    vector<int> iVect;
    vector<int>::iterator iter;
    merge(arr1, arr1 + 5, iSet.begin(), iSet.end(), back_inserter(iVect));
    iter = iVect.begin();
 
    while(iter != iVect.end())
        cout << *(iter++) << " ";
    cout << endl;
 
    system("pause");
    return 0;
}
Глава 15, упражнение 6:
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
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
const int MAX = 10;
 
int main() 
{
    setlocale(LC_CTYPE,"Russian");
    
    vector<int> iVect;
    vector<int>::iterator iter;
    vector<int>::reverse_iterator it;
 
    for(int i = 1; i < MAX; i++)
        iVect.push_back(i);
    
    cout << "Before swap: ";
    for(iter = iVect.begin(); iter != iVect.end(); iter++)
        cout << *(iter) << " ";
    cout << endl;
 
    cout << "After swap: ";
    for(it = iVect.rbegin(); it != iVect.rend(); it++)
        cout << *(it) << " ";
    cout << endl;
 
    system("pause");
    return 0;
}
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Kins
 Аватар для Kins
59 / 58 / 6
Регистрация: 03.02.2013
Сообщений: 167
27.08.2013, 14:16     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #82
Упражнение 15-06

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
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
int _tmain(int argc, _TCHAR* argv[])
{
    setlocale(LC_ALL, "");
    int arr[]={15, 7, 12, 32, 7, 8, 7, 12}, temp;
    vector<int> iList;
    /*
    for(int j=0; j<10; j++)
        iList.push_back(j+1);
        */
    for(int j=0; j<8; j++)
        iList.push_back(arr[j]);
    vector<int>::iterator iter=iList.begin();
    cout <<"До замены: ";
    while(iter!=iList.end())
        cout <<*iter++ <<" ";
    iter=iList.begin();
    vector<int>::reverse_iterator riter=iList.rbegin();
    while(*iter!=*riter){
        //swap(*iter++, *riter);
        temp=*iter;
        *iter++=*riter;
        *riter=temp;
        if(*iter==*riter)
            break;
        ++riter;
    }
    cout <<"\nПосле замены: ";
    for(iter=iList.begin(); iter!=iList.end();)
        cout <<*iter++ <<" ";
    cout <<endl;
    system("pause");
    return 0;
}
kickupduster
 Аватар для kickupduster
4 / 4 / 1
Регистрация: 04.08.2013
Сообщений: 20
27.08.2013, 20:14     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #83
У кого-нибудь есть решение 9-го Упражнения 11-й Главы про скачки?
Lurgee
Сообщений: n/a
01.09.2013, 16:02     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #84
Не обнаружил решения 12 упр. 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
53
#include "stdafx.h"
#include <iostream>
#include "conio.h"
using namespace std;
 
float fmem[20];
int fmem_top=0;
int pmem[20];
 
class Float
{int addr;
 
public:
Float(float f)
{fmem[fmem_top]=f; pmem[fmem_top]=fmem_top; addr=fmem_top;  fmem_top++;}
 
~Float()
{}
 
int& operator &()
{return addr;}
};
 
 
class ptrFloat
{int paddr;
 
public:
ptrFloat(int a):paddr(a)
{}
 
~ptrFloat()
{}
 
float& operator* () const
{return fmem[pmem[paddr]];}
 
};
 
 
int main()
{Float var1 =1.2;
Float var2 =3.4;
ptrFloat ptr1 =&var1;
ptrFloat ptr2 =&var2;
cout<<"*ptr1= "<<*ptr1;
cout<<"\n*ptr2= "<<*ptr2;
*ptr1=5.6;
*ptr2=7.8;
cout<<"\n*ptr1= "<<*ptr1;
cout<<"\n*ptr2= "<<*ptr2;
    _getch();
}
kickupduster
 Аватар для kickupduster
4 / 4 / 1
Регистрация: 04.08.2013
Сообщений: 20
02.09.2013, 17:38     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #85
Цитата Сообщение от MacInsider Посмотреть сообщение
Я хотел спросить у всех, есть ли у кого то решение 1 задания (проекта) из главы 13
Если интересно, то вот мой вариант решения Глава 13. Задание 1
verylong.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
// verylong.h
// описатель класса сверхбольших целых чисел
#include <iostream>
#include <string.h>            //для strlen()и т. п.
#include <stdlib.h>            //для ltoa()
using namespace std;
 
const int SZ = 1000;           //максимальное число разрядов
 
class verylong
  {
  private:
      bool minus;
      char vlstr[SZ];            //число как строка
      int vlen;                  //длина строки verylong
      verylong multdigit(const int) const; //прототипы
      verylong mult10(const verylong) const;// скрытых функций
  public:
    verylong() : vlen(0)       //конструктор без аргументов
      { vlstr[0]='0'; vlstr[1]='\0'; minus = false;}
    verylong(const char s[SZ]) //конструктор (1 аргумент)
      {                        //для строки
          strcpy(vlstr, s); 
          vlen=strlen(s);
          minus = false;
      } 
    verylong(const unsigned long n) //конструктор (1 арг.)
      {                             //для long int
      ltoa(n, vlstr, 10);           //перевести в строку
      strrev(vlstr);                //перевернуть ее
      vlen=strlen(vlstr);           //найти длину
      minus = false;
      } 
    void putvl() const;              //вывести число
    void getvl();       //получить число от пользователя
    verylong operator + (const verylong); //сложить числа
    verylong operator * (const verylong); //умножить
    verylong operator - (const verylong);
    verylong operator / (const verylong);
    verylong operator ++ (int);
    bool operator == (const verylong) const;
    bool operator < (const verylong) const;
    bool operator > (const verylong) const;
    bool operator >= (const verylong) const;
    bool operator <= (const verylong) const;
    bool operator != (const verylong) const;
    friend verylong abs(const verylong&);
  };
verylong.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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
// verylong.cpp
// реализация обработки данных типа verylong
#include "verylong.h"        //заголовочный файл для verylong
//---------------------------------------------------------
void verylong::putvl() const //вывод на экран verylong
  {
  char temp[SZ];
  strcpy(temp,vlstr);        //создать копию
  if (minus == true)
  {
      temp[vlen] = '-';
      temp[vlen+1] = '\0';
  }
  cout << strrev(temp) << endl;      //перевернуть копию
  }                          //и вывести ее
//---------------------------------------------------------
void verylong::getvl()       //получить сверхбольшое число от
                             //пользователя
  {
    cin >> vlstr;              //получить строку от пользователя
    vlen = strlen(vlstr);      //найти ее длину
    strrev(vlstr);             //перевернуть ее
    if (vlstr[vlen-1] == '-') 
    {
        vlstr[vlen-1] = '\0';
        minus = true;
        vlen -= 1;
    }
  }
//---------------------------------------------------------
verylong verylong::operator + (const verylong v)
                             //сложение
  {
      if (minus == true && v.minus == false) return abs(v) - abs(*this);
      if (minus == false && v.minus == true) return abs(*this) - abs(v);
  char temp[SZ];
  int j;
  int maxlen = (vlen > v.vlen) ? vlen : v.vlen; //найти самое длинное число
  int carry = 0;             //установить в 1, если сумма >= 10
  for(j = 0; j<maxlen; j++)  //и так для каждой позиции
    {
    int d1 = (j > vlen-1)  ? 0 : vlstr[j]-'0';    //получить
                                                  //разряд
    int d2 = (j > v.vlen-1) ? 0 : v.vlstr[j]-'0'; //и еще
    int digitsum = d1 + d2 + carry;  //сложить разряды
    if( digitsum >= 10 )             //если перенос, то
      { digitsum -= 10; carry=1; }   //увеличить сумму на 10
    else                     //установить перенос в 1
      carry = 0;             //иначе перенос = 0
    temp[j] = digitsum+'0';  //вставить символ в строку
    }
  if(carry==1)               //если перенос в конце,
    temp[j++] = '1';         //последняя цифра = 1
  temp[j] = '\0';            //поставить ограничитель строки
  if (minus == true && v.minus == true) 
  {
      verylong t(temp); 
      t.minus = true; 
      return t;
  }
  return verylong(temp);     //вернуть временный verylong
  }
//---------------------------------------------------------
verylong verylong::operator - (const verylong v)
{
    if (minus == true && v.minus == false) return *this = *this + v;
    if (minus == false && v.minus == true) return abs(*this) + abs(v);
    char temp[SZ];
    int j;
    int maxlen = (vlen > v.vlen) ? vlen : v.vlen;  //найти самое длинное число
  int carry = 0;             //установить в 1, если сумма >= 10
  for(j = 0; j<maxlen; j++)  //и так для каждой позиции
    {
    int d1 = (j > vlen-1)  ? 0 : vlstr[j]-'0';    //получить
                                                  //разряд
    int d2 = (j > v.vlen-1) ? 0 : v.vlstr[j]-'0'; //и еще
    int digitsum; //сложить разряды
    (*this < v)? digitsum = d2 - d1 - carry : digitsum = d1 - d2 - carry;  
    if( digitsum < 0 )               //если перенос, то
      { digitsum += 10; carry=1; }   //увеличить сумму на 10
    else                     //установить перенос в 1
      carry = 0;             //иначе перенос = 0
    temp[j] = digitsum+'0';  //вставить символ в строку
    }
  temp[j] = '\0';  
  for(int i=j-1; i>0; i--)
  {
      if (temp[i] == '0') temp[i] = '\0';
      else break;
  }
  if (*this < v) 
  {
       verylong t(temp);
       t.minus = true;
       return t;
  }
  return verylong(temp);     //вернуть временный verylong
}
//---------------------------------------------------------
verylong verylong::operator * (const verylong v)//умножение
  {                                             //сверхбольших чисел
  verylong pprod;            //произведение одного разряда
  verylong tempsum;          //текущая сумма
  for(int j=0; j<v.vlen; j++)//для каждого разряда аргумента
    {
    int digit = v.vlstr[j]-'0'; //получить разряд
    pprod = multdigit(digit);   //умножить текущий на него
    for(int k=0; k<j; k++)      //умножить результат на
      pprod = mult10(pprod);    //  степень 10-ти
    tempsum = tempsum + pprod;  //прибавить произведение к
                                //текущей сумме
    }
  if (minus == true || v.minus == true) tempsum.minus = true;
  if (minus == true && v.minus == true) tempsum.minus = false;
  return tempsum;               //вернуть полученную текущую сумму
  }
//---------------------------------------------------------
bool verylong::operator == (const verylong v) const
{return (vlen == v.vlen && strcmp(vlstr,v.vlstr) == 0 && ((minus == true && v.minus == true) || (minus == false && v.minus == false)))? true: false;}
//---------------------------------------------------------
bool verylong::operator < (const verylong v) const
{
 
    if (((vlen < v.vlen) && (minus == false && v.minus == false)) || (minus == true && v.minus == false)) return true;
    if ((vlen > v.vlen) && (minus == true && v.minus == true)) return true;
    if (vlen == v.vlen)
    {
        if (minus == false && v.minus == true) return false;
        char *str1 = new char[vlen], *str2 = new char[v.vlen];
        strcpy(str1,vlstr); strcpy(str2,v.vlstr);
        strrev(str1); strrev(str2);
        if (strcmp(str1, str2) > 0 && (minus == true && v.minus == true)) return true;
        if (strcmp(str1, str2) < 0 && (minus != true && v.minus != true)) return true;
    }
    return false;
}
//---------------------------------------------------------
bool verylong::operator > (const verylong v) const
{
    verylong t(vlstr);
    t.minus = minus;
    return (!(t < v) && !(t == v))? true: false;
}
//---------------------------------------------------------
bool verylong::operator <= (const verylong v) const
{
    verylong t(vlstr);
    t.minus = minus;
    return (t < v || t == v)? true: false;
}
//---------------------------------------------------------
bool verylong::operator >= (const verylong v) const
{
    verylong t(vlstr);
    t.minus = minus;
    return (t > v || t == v)? true: false;
}
//---------------------------------------------------------
bool verylong::operator != (const verylong v) const
{
    verylong t(vlstr);
    t.minus = minus;
    return (!(t == v))? true: false;
}
//---------------------------------------------------------
verylong verylong::operator ++ (int)
{return *this = *this + 1;}
//---------------------------------------------------------
verylong abs(const verylong &v)
{
    verylong t;
    t = v;
    t.minus = false;
    return t;
}
//---------------------------------------------------------
verylong verylong::operator / (const verylong v) //целочисленное деление
{
    char *str_v = new char[vlen]; //временная строка
    strcpy(str_v,vlstr); strrev(str_v); //переворачиваем ее в нормальный вид
    verylong b, rez, vltemp, null;
    null.vlen = 1; 
    b = abs(v); //значение по модулю
    if (b == null) {cerr << "ОШИБКА!!! Деление на ноль!!!" << endl; return null;}
    if (abs(*this) < b) return null; //если делимое меньше делителя - возвращаем ноль
    for(int i=0, n=0; i<vlen;) //перебираем разряды делимого
    {
        while(vltemp < b) //берем разряды делимого
        {                 //пока не получим число большее делителя
            if (i >= vlen) return rez; 
            int d = str_v[i]-'0'; //берем разряд
            if (d == 0 && vltemp == null) rez = mult10(rez); //сносим нули при необходимости
            else vltemp = mult10(vltemp) + d; //формируем число 
            i++;
        }
        if (vltemp >= b) //если получили такое число
        {
            while(vltemp >= b) //уменшаем его
            {                  //пока остаток не станет меньше делителя
                vltemp = vltemp - b; 
                n++; //считаем значение разряда
            }
            rez = mult10(rez) + n; //формируем результат
            n = 0; //зануляем значение разряда
        }          //и повторяем цикл пока не пройдем весь велитель
    }
    if (minus == true || v.minus == true) rez.minus = true; //учитываем знаки исходных данных
    if (minus == true && v.minus == true) rez.minus = false;
    return rez;
}
//---------------------------------------------------------
verylong verylong::mult10(const verylong v) const //умножение аргумента 
                                                  //на 10
  {                
  char temp[SZ];
  for(int j=v.vlen-1; j>=0; j--)//сдвинуться на один разряд
    temp[j+1] = v.vlstr[j];     //выше
  temp[0] = '0';                //обнулить самый младший разряд
  temp[v.vlen+1] = '\0';        //поставить ограничитель строки
  return verylong(temp);        //вернуть результат
  }
//---------------------------------------------------------
verylong verylong::multdigit(const int d2) const
  {                          //умножение числа на
  char temp[SZ];             //аргумент (цифру)
  int j, carry = 0;
  for(j = 0; j<vlen; j++)    //для каждого разряда
    {              //  в этом сверхбольшом
    int d1 = vlstr[j]-'0';   //получить значение разряда
    int digitprod = d1 * d2; //умножить на цифру
    digitprod += carry;      //добавить старый перенос
    if( digitprod >= 10 )    //если возник новый перенос,
      {
      carry = digitprod/10;  //переносу присвоить //значение старшего разряда
      digitprod -= carry*10; //результату - младшего
      }
    else
      carry = 0;             //иначе перенос = 0
    temp[j] = digitprod+'0'; //вставить символ в строку
    }
  if(carry != 0)             //если на конце перенос,
    temp[j++] = carry+'0';   //это последний разряд
  temp[j] = '\0';            //поставить ограничитель
  return verylong(temp);     //вернуть сверхбольшое число
  }
main.cpp
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include "verylong.h"    //заголовочный файл verylong
int main()
  {
      setlocale(0,"rus");
      verylong *a, *b, *r; //объекты класса
      while(true){
      a = new verylong; b = new verylong; r = new verylong;
      cout << "Введите число: "; a->getvl(); //ввод данных
      cout << "Введите число: "; b->getvl();
      *r = *a + *b;
      cout << "Результат: "; r->putvl();
      *r = *a - *b;
      cout << "Результат: "; r->putvl();
      *r = *a * *b;
      cout << "Результат: "; r->putvl();
      *r = *a / *b;
      cout << "Результат: "; r->putvl();
      delete a,b,r;} //вывод на экран
  system("pause");
  return 0;
  }
Purcell
 Аватар для Purcell
0 / 0 / 0
Регистрация: 14.08.2013
Сообщений: 20
04.09.2013, 01:24     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #86
Глава 5. Задание 2.
В ответах у самого Лафоре решение этого задания не предусматривает возможность возведения в степень с отрицательным показателем. Поэтому я немного дополнил функцию.

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
// 02.cpp
// функция возведения в степень
 
# include <iostream>
 
using namespace std;
// объявление функции; по умолчанию второй аргумент равен 2
double power(double base, int exponent = 2);
int main()
{
    double base;    // основание степени
    int exponent;   // показатель степени
    char ch;        // выбор пользователя
    cout << "Введите число: ";
    cin >> base;
    cout << "Будете возводить его в степень с показателем, отличным от 2? (y/n) ";
    cin >> ch;
    if (ch == 'y')
    {
        cout << "Введите показатель степени: ";
        cin >> exponent;
        cout << "Результат: " << power(base, exponent) << endl;
    }
    else
    {
        cout << "Результат: " << power(base) << endl;
    }
    return 0;
}
//--------------------------------------------------------------------
// определение функции
double power(double b, int e)
{
    double result = 1.0;  // начинаем с 1.0
    if (e >= 0)           // степень с положительным или нулевым
    {                     // показателем
        for (int i = 0; i < e; i++)
        {
            result *= b;
        }
    }
    else                  // степень с отрицательным показателем
    {
        e = 0 - e;
        for (int i = 0; i < e; i++)
        {
            result *= b;
        }
        result = 1 / result;
    }
    return result;
}
xypc
10 / 8 / 1
Регистрация: 31.05.2013
Сообщений: 65
06.09.2013, 19:10     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #87
Я так понял, что никто кроме меня не заметил, что третья задача во второй главе решена неправильно, да? Как бы в условии было задано, что использовать нужно константу(!)
kickupduster
 Аватар для kickupduster
4 / 4 / 1
Регистрация: 04.08.2013
Сообщений: 20
07.09.2013, 11:13     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #88
Цитата Сообщение от xypc Посмотреть сообщение
Я так понял, что никто кроме меня не заметил, что третья задача во второй главе решена неправильно, да? Как бы в условии было задано, что использовать нужно константу(!)
Не драматизируй!) Это не критично, есть проблемы куда серьезней этой
Рики
6 / 6 / 1
Регистрация: 27.02.2013
Сообщений: 23
02.10.2013, 07:40     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #89
Глава 11

Задание 11.5
Кликните здесь для просмотра всего текста
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
#include <iostream>
using namespace std;
const int LEN = 80;
////////////////////////////////////////////////////////////////////////////////
class publication
{
   private:
       char name[LEN]; 
       float price;
   public:
    virtual void getdata ()
      {
            cout<<"\nВведите имя: ";  cin>>name; 
            cout<<"Введите цену: "; cin>>price; 
      } 
    virtual void putdata ()
      {
            cout<<"\n Название: "<<name;   
            cout<<"\n Цена: "<<price; 
      } 
    virtual bool isOverersize()=0;
};
////////////////////////////////////////////////////////////////////////////////
class book: public publication
{
   private:
       int pages; 
   public:
    void getdata ()
      {
            publication::getdata();
            cout<<"Введите количество страниц: ";  cin>>pages; 
      } 
    void putdata ()
      {
            publication::putdata();
            cout<<"\n Количество страниц: "<<pages;   
      }
    virtual bool isOverersize()
      {return (pages>800)? true : false;}
};
////////////////////////////////////////////////////////////////////////////////
class type: public publication
{
   private:
       float min; 
   public:
    void getdata ()
      {
            publication::getdata();
            cout<<"Введите длительность аудиозаписи в минутах: ";  cin>>min; 
      } 
    void putdata ()
      {
            publication::putdata();
            cout<<"\n Общая длительность в минутах: "<<min;   
      } 
    virtual bool isOverersize()
      {return (min>90)? true : false;}
};
////////////////////////////////////////////////////////////////////////////////
int main()
{
setlocale (LC_ALL, "russian");
publication* pointer[100];
int n = 0;
char choice;
do {
    cout<<"Книга (b) или запись (r)?  ";
    cin>>choice;
    if (choice=='b')
        pointer[n]=new book;
    else
        pointer[n]=new type;
    pointer[n++]->getdata();
    cout<<"Продолжить ввод (y/n)? ";
    cin>>choice;
    } while (choice=='y');
for (int j=0; j<n; j++)
    {
    pointer[j]->putdata ();
    if(pointer[j]->isOverersize ())
        cout<<"Превышение размера! ";
    }
system("Pause");
return 0;
}

Задание 11.6
Кликните здесь для просмотра всего текста
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
#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <process.h>
using namespace std;
static const int MAX = 26;
/////////////////////////////////////////////////////////////
class bMoney
{
  private:
    double longMoney;
  public:
    char chMoney[MAX];
    bMoney ():longMoney(0.0) // конструктор
      {chMoney[0]='$';}
    bMoney (double chislo) // конструктор
      {longMoney=chislo;}
 
    void getMoney ()
        {
            cout << "Введите денежную сумму" << endl;
            cin >> longMoney;
        }
    double vozvrat ()
        {
            return longMoney;
        }
    double mstold ( char []);
 
    bMoney operator+ (bMoney m2)
        {return bMoney (longMoney + m2.longMoney);}
 
    bMoney operator- (bMoney m2)
        {return bMoney (longMoney - m2.longMoney);}
 
    bMoney operator* (double d2)
        {return bMoney (longMoney * d2);}
 
    friend bMoney operator* (bMoney m1, bMoney m2)
        {return bMoney (m1.longMoney * m2.longMoney);}
 
    friend bMoney operator/ (bMoney m1, bMoney m2)
        {return bMoney (m1.longMoney / m2.longMoney);}
 
    void display ( )const
      {
           cout<<fixed<<setprecision(2)<<"$"<<longMoney << endl; 
      }           
};
/////////////////////////////////////////////////////////////
int main ( )
{
  setlocale (LC_ALL, "russian");
  bMoney m1, m2, m3, m4, m5, m6, m7, m8, m9;
  double d1;
  char answer = 'y';
  while (answer!='n')
  {
    //cout << "Введите количество изделий." << endl;
    //cin >> d1;
    d1 = 10;
    m1 = 200;
    m2 = 10;
    m3 = m1 + m2;
    m4 = m1 - m2;
    m5 = m1 * d1;
    m6 = m1 / m2;
    m7 = m1 / d1;
    m8 = 5.5 * m2;
    m9 = 500 / m1;
 
    m3.display();
    m4.display();
    m5.display();
    m6.display();
    m7.display();
    m8.display();
    m9.display();
 
    cout << "Продолжить ввод?" << endl;
    cin >> answer;
 
  } 
  system("pause");
  return 0;
}

Задание 11.7
Кликните здесь для просмотра всего текста
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
#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <process.h>
#include <math.h> 
using namespace std;
static const int MAX = 26;
/////////////////////////////////////////////////////////////
class bMoney
{
  private:
    double longMoney;
  public:
    char chMoney[MAX];
    bMoney ():longMoney(0.0) // конструктор
      {chMoney[0]='$';}
    bMoney (double chislo) // конструктор
      {longMoney=chislo;}
 
    void getMoney ()
        {
            cout << "Введите денежную сумму" << endl;
            cin >> longMoney;
            
        }
    double vozvrat ()
        {
            return longMoney;
        }
    double mstold ( char []);
 
    bMoney operator+ (bMoney m2)
        {return bMoney (longMoney + m2.longMoney);}
 
    bMoney operator- (bMoney m2)
        {return bMoney (longMoney - m2.longMoney);}
 
    bMoney operator* (double d2)
        {return bMoney (longMoney * d2);}
 
    friend bMoney operator* (bMoney m1, bMoney m2)
        {return bMoney (m1.longMoney * m2.longMoney);}
 
    friend bMoney operator/ (bMoney m1, bMoney m2)
        {return bMoney (m1.longMoney / m2.longMoney);}
 
    void display ()
      {
           cout<<fixed<<setprecision(2)<<"$"<<longMoney << endl; 
      }           
    bMoney round();
};
//--------------------------------------------------------------------
    bMoney bMoney::round ()
    {
        double fractpart, intpart;
        fractpart = modf(longMoney, &intpart);
        if (fractpart<0.5)
            longMoney = intpart;
        else longMoney = intpart+1;
        return bMoney(longMoney);
            
 
    }
/////////////////////////////////////////////////////////////
int main ( )
{
  setlocale (LC_ALL, "russian");
  bMoney m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11;
  double d1;
  char answer = 'y';
  while (answer!='n')
  {
    d1 = 10;
    m1 = 200.45;
    m2 = 10.55;
    m3 = m1 + m2;
    m4 = m1 - m2;
    m5 = m1 * d1;
    m6 = m1 / m2;
    m7 = m1 / d1;
    m8 = 5.5 * m2;
    m9 = 500 / m1;
    m10 = m1.round();
    m11 = m2.round();
    
    m3.display();
    m4.display();
    m5.display();
    m6.display();
    m7.display();
    m8.display();
    m9.display();
    m10.display();
    m11.display();
 
    cout << "Продолжить ввод?" << endl;
    cin >> answer;
 
  } 
  system("pause");
  return 0;
}

Задание 11.8
Кликните здесь для просмотра всего текста
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
// parse.cpp
#include <iostream>
#include <cstring>                   //for strlen(), etc
#include <stdlib.h> 
using namespace std;
const int LEN = 80;    //length of expressions, in characters
const int MAX = 40;    //size of stack
////////////////////////////////////////////////////////////////
  class Token                      // Абстрактный базовый класс
    {
    public:
      virtual void showOperNumber()=0; // чистая виртуальная
      virtual char getOperator()=0;             // функция
      virtual float getNumber()=0; 
 
      
    };
////////////////////////////////////////////////////////////////
  class Operator : public Token
    {
    private:
      char oper;             // Операторы +, –, *, /
    public:
      Operator(char c): oper(c)      // конструктор устанавливает значение
        {}
      void showOperNumber()    // получить значение
        {cout<<oper<<endl; }
      virtual float getNumber()
        { return 0.f; }
      char getOperator()
        {return oper;}
     
    };
////////////////////////////////////////////////////////////////
  class Number : public Token
    {
    private:
      float fnum;            // число
    public:
      Number(float f): fnum(f)         // конструктор устанавливает значение
         {}
      void showOperNumber()     // получить значение
        {cout<<fnum<<endl;}
      float getNumber()
        {return fnum;}
      virtual char getOperator()
        { return 0.f; }
    };
////////////////////////////////////////////////////////////////////
class Stack
   {
   private:
      Token* atoken[100];    //содержит типы Operator* и Number*                  
      int top;                       //number of top of stack
   public:
      Stack()                        //constructor
         { top = 0; }
      void push(Token* var)            //put char on stack
         { atoken[++top] = var; }
      Token* pop()                     //take char off stack
         { return atoken[top--]; }
      int gettop()                   //get top of stack
         { return top; }
   };
////////////////////////////////////////////////////////////////
class express
{
    private:
        Stack s;
        char* pStr;
        int len;
    public:
        express (char* ptr)
        {
            pStr=ptr;
            len =strlen(pStr);
        }
        void parse ();     // разбор выражения
        float solve ();      // получение результата
};
//--------------------------------------------------------------
void express::parse()
{
    char chifra [LEN];    //символы из строки
    float lastval;        // последнее значение
    char lastop;          // последний оператор
    Number* ptrN;
    Operator* ptrO;
    float n;
    char Ch;  
    int j=0;
     
 
    for(j; j<len; j++)          //для всех символов в строке
    {
        if (pStr[j]>='0' && pStr[j]<='9' || pStr[j]==',')
        {
            int i=0;
            while (pStr[j]>='0' && pStr[j]<='9' || pStr[j]==',')  // получаем число 
            {
                chifra [i]=pStr[j];
                j++; i++;
            }
            j--;
            chifra [i]='\0';
            n = atof(chifra);
            ptrN = new Number(n);
            s.push(ptrN);                                       // заносим  в стек
        }
        else if(pStr[j]=='+' || pStr[j]=='-' || pStr[j]=='*' || pStr[j]=='/')
        {
            Ch = pStr[j];
            if (s.gettop()==1)                                    // если это первый оператор, то помещаем в стек
            {
                ptrO = new Operator(Ch);
                s.push(ptrO);   
            }
            else
            {
                lastval=s.pop()->getNumber();                //получение предыдущего числа
                lastop=s.pop()->getOperator();              //получение предыдущего оператора
                // если это * или / , а предыдущий был + или -, то
                if( (pStr[j]=='*' || pStr[j]=='/') && (lastop=='+' || lastop=='-') )
                {
                    ptrO = new Operator(lastop);   //отменяем последние два взятия из стека
                    s.push(ptrO);   
                    ptrN = new Number(lastval);
                    s.push(ptrN);   
               }
               else                     //помещаем в стек текущий оператор 
               {
               switch(lastop)        
                  {                  
                  case '+': ptrN = new Number(s.pop()->getNumber() + lastval); s.push(ptrN); break;
                  case '-': ptrN = new Number(s.pop()->getNumber() - lastval); s.push(ptrN); break;
                  case '*': ptrN = new Number(s.pop()->getNumber() * lastval); s.push(ptrN); break;
                  case '/': ptrN = new Number(s.pop()->getNumber() / lastval); s.push(ptrN); break;
                  default:  cout << "\nUnknown oper"; exit(1);
                  }  
               }  
            ptrO = new Operator(pStr[j]);
            s.push(ptrO);              //помещаем в стек текущий оператор 
            }  
         }  
   
      else                           //что-то левое
         { cout << "\nUnknown input character"; exit(1); }
   }
}
//-------------------------------------------------------------
float express::solve ()  //убираем данные из стека
{
    float lastval;              
    while(s.gettop() > 1)
      {
      lastval = s.pop()->getNumber();               //предыдущее значение 
      Number* ptrN;
      switch( s.pop()->getOperator() )              //получение предыдущего оператора
         {                           //do operation, push answer
         case '+': ptrN = new Number(s.pop()->getNumber() + lastval); s.push(ptrN); break;
         case '-': ptrN = new Number(s.pop()->getNumber() - lastval); s.push(ptrN); break;
         case '*': ptrN = new Number(s.pop()->getNumber() * lastval); s.push(ptrN); break;
         case '/': ptrN = new Number(s.pop()->getNumber() / lastval); s.push(ptrN); break;
         default:  cout << "\nUnknown operator"; exit(1);
         }  
      }  
   return float (s.pop()->getNumber());//последний оператор в стеке это результат
}
////////////////////////////////////////////////////////////////
 
int main()
   {
   setlocale (LC_ALL, "russian");
   char ans;            // 'д' или 'н'
   //char stroka [LEN]="12,05+13,05+14,05*2";                          //char from input string
   char stroka [LEN];
   cout << "\nВведите арифметическое выражение в виде 2+3*4/3-2"
          "\nЧисла должны быть из одной цифры"
          "\nНе используйте пробелы и скобки";
 
   do
   {
       cout << "\nВыражение: ";
       cin >> stroka;                          // вводим строку
       express* eptr = new express (stroka);
       eptr->parse();
       cout <<"\nРезультат: "
           << eptr->solve();
       delete eptr;
       cout << "Еще одно выражение (y/n)? ";
    cin >> ans;
   }
   while ( ans == 'y' );
   system("pause");
   return 0;
   }

Задание 11.9
Пояснения
Кликните здесь для просмотра всего текста
Своеобразное задание. Возникли проблемы при запуске исходника horse. пилагаю к заданию рабочее на visual studio 2012 решение Horse.7z
По хорошему, как думаю я, нужно было сделать два наследственных класса comhorse и comtrack. Дальше, перегрузить конструктор comtrack, дабы он использовал comhorse, а затем переделать функцию run(). и прикрепить к ней horse_tick. К сожалению, я не смог справиться с переопределением конструктора в классе comtrack. Поэтому, просто переделал все заново (без наследования) и запустил работающий пример с ведущей лошадью. Надеюсь, этот файл кому-то поможет. С удовольствием посмотрю на сделанное, как надо, решение этой задачи.

Кликните здесь для просмотра всего текста
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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
#include <iostream>
#include <cstdlib>
#include <ctime>
#include "stdafx.h"
#include "msoftcon.h"
using namespace std;
const int CPF = 5;
const int maxHorses = 7;
///////////////////////////////////////////////////////////
//class track;
/////////////////////////////////////////////////////////////
//class horse
//{
//  protected:
//    const track* ptrTrack;
//    const int horse_number;
//    float finish_time;
//    float distance_run;
//  public:
//    horse ( const int n, const track* ptrT ) : 
//      horse_number ( n ),
//      ptrTrack ( ptrT ),
//      distance_run ( 0.0 )
//      { }
//    ~horse ( )
//      { }
//    void display_horse ( const float elapsed_time );
//};
//
/////////////////////////////////////////////////////////////
//class track
//{
//  protected:
//    horse* hArray [ maxHorses ];
//    int total_horses;
//    int horse_count;
//    const float track_length;
//    float elapsed_time;
//  public:
//  track();
//    track ( float lenT, int nH );
//    ~track ( );
//    void display_track ( );
//    void run ( );
//    float get_track_len ( ) const;
//};
////-----------------------------------------------------------
//void horse::display_horse ( float elapsed_time )
//{
//  set_cursor_pos ( 1 + int ( distance_run * CPF ), 2 + horse_number * 2 );
//  set_color ( static_cast<color>( cBLUE + horse_number ) );
//  char horse_char = '0' + static_cast<char>( horse_number );
//  _putch ( ' ' );    // выводит на экран символы
//  _putch ( '\xDB' ); 
//  _putch ( horse_char ); 
//  _putch ( '\xDB' );
//  if ( distance_run < ptrTrack->get_track_len ( ) + 1.0 / CPF )
//  {       //работает пока пробег!=длинне трека
//    if ( rand ( ) % 3 )  //в диапазоне от 0 до 3
//      distance_run += 0.2F;//если совпадает, лошадь продвигается на 0.2
//    finish_time = elapsed_time;  //учитывает время потраченное лошадью на забег
//  }
//  else
//  {
//    int mins = int ( finish_time ) / 60;
//    int secs = int ( finish_time ) - mins * 60;
//    cout << " Time = " << mins << ":" << secs;
//  }
//}
////-----------------------------------------------------------
//track::track ( float lenT, int nH ) : // добавляет в массив лошади
//  track_length ( lenT ),
//  total_horses ( nH ),
//  horse_count ( 0 ),
//  elapsed_time ( 0.0 )
//{
//  init_graphics ( );
//  total_horses = ( total_horses > maxHorses ) ? maxHorses : total_horses; //проверка на количество лошадей
//  for ( int j = 0; j < total_horses; j++ )
//    hArray [ j ] = new horse ( horse_count++, this );
//
//  time_t aTime;
//  srand ( static_cast<unsigned>( time ( &aTime ) ) );  //генерирует псевдослучайные числа в зависимости от времени
//  display_track ( );                                   //начинает рисовать трек
//}
////-----------------------------------------------------------
//track::~track ( )
//{
//  for ( int j = 0; j < total_horses; j++ )
//    delete hArray [ j ];
//}
////-----------------------------------------------------------
//void track::display_track ( ) //отображает вертикальные полоски
//{
//  clear_screen ( );           //очищает консоль
//
//  for ( int f = 0; f <= track_length; f++ )  //рисует вертикальную полосоку 
//    for ( int r = 1; r <= total_horses * 2 + 1; r++ ) //в зависимости от 
//    {                                                 //количества лошадей   
//      set_cursor_pos ( f * CPF + 5, r );
//      if ( f == 0 || f == track_length )
//        cout << '\xDE';  //толстые полоски
//      else
//        cout << '\xB3';  //тонкие полоски
//    }
//}
////-----------------------------------------------------------
//void track::run ( )      //перемещает лошади по экрану
//{                        //и отображает 
//  while ( !_kbhit ( ) )  //цикл будет выполняться, пока не нажата клавиша клавиатуры
//  {
//    elapsed_time += 1.75; //затраченное время
//
//    for ( int j = 0; j < total_horses; j++ )
//  {
//      hArray [ j ]->display_horse ( elapsed_time );
//  }
//    wait ( 500 ); //после прорисовки лошадей ждет 500 
//  }
//  _getch ( );   //возвращает очередной символ, считанный с консоли, но не выводит этот сим*вол на экран
//  cout << endl;
//}
////-----------------------------------------------------------
//float track::get_track_len ( ) const
//  { return track_length; }
////-----------------------------------------------------------
//float horse::get_distance_run ( )
//      { return distance_run; }
///////////////////////////////////////////////////////////
//Наследуемые классы
///////////////////////////////////////////////////////////
class comtrack;
///////////////////////////////////////////////////////////
class comhorse
{
    private:
        const comtrack* ptrcTrack;
        const int horse_number;
        float finish_time;
        float distance_run;
    public:
        comhorse (const int n, const /*track* ptrT*/ comtrack* ptrcT):
        horse_number ( n ),
        ptrcTrack ( ptrcT ),
        distance_run ( 0.0 )
            {}
        void horse_tick ();
        float get_distance_run()
        {return distance_run;}
        void display_comhorse ( const float elapsed_time );
};
///////////////////////////////////////////////////////////
class comtrack
{
    private:
        comhorse* hArray [ maxHorses ];
        int total_horses;
        int horse_count;
        const float track_length;
        float elapsed_time;
    public:
        //comtrack();
        comtrack(float lenT, int nH):
        track_length ( lenT ),
        total_horses ( nH ),
        horse_count ( 0 ),
        elapsed_time ( 0.0 )
        {
            init_graphics ( );
            total_horses = ( total_horses > maxHorses ) ? maxHorses : total_horses; //проверка на количество лошадей
            for ( int j = 0; j < total_horses; j++ )
                hArray [ j ] = new comhorse ( horse_count++, this );
            time_t aTime;
            srand ( static_cast<unsigned>( time ( &aTime ) ) );  //генерирует псевдослучайные числа в зависимости от времени
            display_comtrack ( );                                   //начинает рисовать трек
        }
        ~comtrack ( )
        {}
        void comrun ( );
        void display_comtrack ( );
        float get_comtrack_len ( ) const;
        //friend void horse_tick ( int, comhorse*  );
};
//-----------------------------------------------------------
void comhorse::display_comhorse ( float elapsed_time )
{
  set_cursor_pos ( 1 + int ( distance_run * CPF ), 2 + horse_number * 2 );
  set_color ( static_cast<color>( cBLUE + horse_number ) );
  char horse_char = '0' + static_cast<char>( horse_number );
  _putch ( ' ' );    // выводит на экран символы
  _putch ( '\xDB' ); 
  _putch ( horse_char ); 
  _putch ( '\xDB' );
  if ( distance_run < ptrcTrack->get_comtrack_len ( ) + 1.0 / CPF )
  {       //работает пока пробег!=длинне трека
    if ( rand ( ) % 3 )  //в диапазоне от 0 до 3
      distance_run += 0.2F;//если совпадает, лошадь продвигается на 0.2
    finish_time = elapsed_time;  //учитывает время потраченное лошадью на забег
  }
  else
  {
    int mins = int ( finish_time ) / 60;
    int secs = int ( finish_time ) - mins * 60;
    cout << " Time = " << mins << ":" << secs;
  }
}
//-----------------------------------------------------------
void comtrack::display_comtrack ( ) //отображает вертикальные полоски
{
  clear_screen ( );           //очищает консоль
 
  for ( int f = 0; f <= track_length; f++ )  //рисует вертикальную полосоку 
    for ( int r = 1; r <= total_horses * 2 + 1; r++ ) //в зависимости от 
    {                                                 //количества лошадей   
      set_cursor_pos ( f * CPF + 5, r );
      if ( f == 0 || f == track_length )
        cout << '\xDE';  //толстые полоски
      else
        cout << '\xB3';  //тонкие полоски
    }
}
//-----------------------------------------------------------
float comtrack::get_comtrack_len ( ) const
  { return track_length; }
//-----------------------------------------------------------
void comtrack::comrun ( )      //перемещает лошади по экрану
{                        //и отображает 
   while ( !_kbhit ( ) )  //цикл будет выполняться, пока не нажата клавиша клавиатуры
  {
    elapsed_time += 1.75; //затраченное время
 
    for ( int j = 0; j < total_horses; j++ )
    {
      int z = 0;
      hArray [ j ]->display_comhorse ( elapsed_time );
      if ( hArray [ j ]->get_distance_run() > track_length / 2.01 &&
           hArray [ j ]->get_distance_run() < track_length / 1.9  )
            for ( int k = 0;  k <total_horses; k++)
            {
                if (hArray [ j ]->get_distance_run() >= hArray [ k ]->get_distance_run())
                {
                    z++;
                    if (z==total_horses)
                        hArray [ j ]->horse_tick ();
                }
            }   
    }
    wait ( 500 ); //после прорисовки лошадей ждет 500 
  }
  _getch ( );   //возвращает очередной символ, считанный с консоли, но не выводит этот сим*вол на экран
  cout << endl;
}
///////////////////////////////////////////////////////////
void comhorse::horse_tick ()
{
    set_cursor_pos ( 1 + int ( distance_run * CPF ), 2 + horse_number * 2 );
    set_color ( static_cast<color>( cBLUE + horse_number ) );
    char horse_char = '0' + static_cast<char>( horse_number );
    distance_run += 0.35F;//если совпадает, лошадь продвигается на 0.2
    _putch ( '   ' );    // выводит на экран символы
    _putch ( '\xDB' ); 
    _putch ( horse_char ); 
    _putch ( '\xDB' );
}
///////////////////////////////////////////////////////////
 
int main ( )
{
  //setlocale (LC_ALL, "russian");
  float length;
  int total;
 
  cout << "\nVvedite dlinnu distancii (ot 1 do 12): ";
  cin >> length;
  //length = 5;
  cout << "\nVvesite kolichestvo loshadei (ot 1 do 7): ";
  cin >> total;
  //total = 3;
  comtrack theTrack ( length, total );
  theTrack.comrun ( );
 
  system("Pause");
  return 0;
}

Задание 11.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
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
#include <iostream>
using namespace std;
///////////////////////////////////////////////////////////
struct link   // один элемент списка
{
  int data;   // некоторые данные
  link* next; // указатель на следующую структуру
};
///////////////////////////////////////////////////////////
class linklist // список
{
  private:
    link* first;
  public:
    linklist ( )            // конструктор без параметров
      { first = NULL; }     // первого элемента пока нет
    ~linklist();
    void additem ( int d ); // добавление элемента
    void display ( );       // показ данных
    void operator = (linklist& ); //оператор присваивания
    linklist(linklist&);          //оператор копирования
};
///////////////////////////////////////////////////////////
void linklist::additem ( int d ) // добавление элемента
{
  link* newlink = new link;      // выделяем память
  newlink->data = d;             // запоминаем данные
  newlink->next = first;         // запоминаем значение first
  first = newlink;               // first теперь указывает на новый элемент
}
///////////////////////////////////////////////////////////
void linklist::display ( )
{
  link* current = first;           // начинаем с первого элемента
  while( current )                 // пока есть данные
  {
    cout << current->data << endl; // печатаем данные
    current = current->next;       // двигаемся к следующему элементу
  }
}
///////////////////////////////////////////////////////////
linklist::~linklist()
    {
        link*current =first;   //установить указатель на первый элемент
        while(current !=NULL ) //выход по достижении последнего элемента
        {
            link*temp =current;  //сохранить указатель на данный элемент
            current =current->next;  //получить ссылку на следующую ссылку
            cout<<"Удаляем"<<endl;
            delete temp;               //удалить эту ссылку
      }
    }
///////////////////////////////////////////////////////////
void linklist::operator = (linklist& l1) //оператор присваивания
{
    link*current =l1.first;   //установить указатель на первый элемент
    while(current !=NULL ) //выход по достижении последнего элемента
        {
            link* newlink = new link;
            newlink->data = current->data;  //сохранить указатель на данный элемент
            newlink->next =first;
            first = newlink;
            current =current->next;  //получить ссылку на следующую ссылку
        }
    cout<<"Оператор присваивания.";
}
///////////////////////////////////////////////////////////
linklist::linklist(linklist& l1)
{
    first = NULL;
    link*current =l1.first;   //установить указатель на первый элемент
    while(current !=NULL ) //выход по достижении последнего элемента
        {
            link* newlink = new link;
            newlink->data = current->data;  //сохранить указатель на данный элемент
            newlink->next =first;
            first = newlink;
            current =current->next;  //получить ссылку на следующую ссылку
        }
      cout<<"Оператор копирования.";
}
 
///////////////////////////////////////////////////////////
int main ( )
{
  setlocale (LC_ALL, "russian");
  linklist* li = new linklist;       // создаем переменную-список
  linklist* list2 = new linklist;
 
  li->additem ( 25 ); // добавляем туда несколько чисел
  li->additem ( 36 );
  li->additem ( 49 );
  li->additem ( 64 );
 
  *list2 = *li; 
  linklist list3 (*li) ;                      // для указателей операторы не перегрузишь, с шаблонами или без них... 
                      // в общем, указатели так и так разыменовывать, 
                      //а для класса можно перегрузить почти любые операторы. 
  delete  li;     
  //li->display ( );    // показываем список
  list2->display ( );    // показываем список
  list3.display ( );    // показываем список
  cout<<"Завершение программы.";
  system("pause");
  return 0;
}

Задание 11.11
Кликните здесь для просмотра всего текста
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
// parse.cpp
#include <iostream>
#include <cstring>                   //for strlen(), etc
#include <stdlib.h> 
#include <math.h> 
using namespace std;
const int LEN = 80;    //length of expressions, in characters
const int MAX = 40;    //size of stack
////////////////////////////////////////////////////////////////
  class Token                      // Абстрактный базовый класс
    {
    public:
      virtual void showOperNumber()=0; // чистая виртуальная
      virtual char getOperator()=0;             // функция
      virtual float getNumber()=0; 
 
      
    };
////////////////////////////////////////////////////////////////
  class Operator : public Token
    {
    private:
      char oper;             // Операторы +, –, *, /
    public:
      Operator(char c): oper(c)      // конструктор устанавливает значение
        {}
      void showOperNumber()    // получить значение
        {cout<<oper<<endl; }
      virtual float getNumber()
        { return 0.f; }
      char getOperator()
        {return oper;}
     
    };
////////////////////////////////////////////////////////////////
  class Number : public Token
    {
    private:
      float fnum;            // число
    public:
      Number(float f): fnum(f)         // конструктор устанавливает значение
         {}
      void showOperNumber()     // получить значение
        {cout<<fnum<<endl;}
      float getNumber()
        {return fnum;}
      virtual char getOperator()
        { return 0.f; }
    };
////////////////////////////////////////////////////////////////////
class Stack
   {
   private:
      Token* atoken[100];    //содержит типы Operator* и Number*                  
      int top;                       //number of top of stack
   public:
      Stack()                        //constructor
         { top = 0; }
      void push(Token* var)            //put char on stack
         { atoken[++top] = var; }
      Token* pop()                     //take char off stack
         { return atoken[top--]; }
      int gettop()                   //get top of stack
         { return top; }
   };
////////////////////////////////////////////////////////////////
class express
{
    private:
        Stack s;
        char* pStr;
        int len;
    public:
        express (char* ptr)
        {
            pStr=ptr;
            len =strlen(pStr);
        }
        void parse ();     // разбор выражения
        float solve ();      // получение результата
        double round (double);
};
//--------------------------------------------------------------------
double express::round (double n)
    {
        double fractpart, intpart;
        fractpart = modf(n, &intpart);
        if (fractpart<0.5)
            n = intpart;
        else n = intpart+1;
        return n;
            
 
    }
//--------------------------------------------------------------
void express::parse()
{
    char chifra [LEN];    //символы из строки
    float lastval;        // последнее значение
    char lastop;          // последний оператор
    Number* ptrN;
    Operator* ptrO;
    float n;
    char Ch;  
    int j=0;
     
 
    for(j; j<len; j++)          //для всех символов в строке
    {
        if (pStr[j]>='0' && pStr[j]<='9' || pStr[j]==',')
        {
            int i=0;
            while (pStr[j]>='0' && pStr[j]<='9' || pStr[j]==',')  // получаем число 
            {
                chifra [i]=pStr[j];
                j++; i++;
            }
            j--;
            chifra [i]='\0';
            n = round(atof(chifra));
            ptrN = new Number(n);
            s.push(ptrN);                                       // заносим  в стек
        }
        else if(pStr[j]=='+' || pStr[j]=='-' || pStr[j]=='*' || pStr[j]=='/')
        {
            Ch = pStr[j];
            if (s.gettop()==1)                                    // если это первый оператор, то помещаем в стек
            {
                ptrO = new Operator(Ch);
                s.push(ptrO);   
            }
            else
            {
                lastval=s.pop()->getNumber();                //получение предыдущего числа
                lastop=s.pop()->getOperator();              //получение предыдущего оператора
                // если это * или / , а предыдущий был + или -, то
                if( (pStr[j]=='*' || pStr[j]=='/') && (lastop=='+' || lastop=='-') )
                {
                    ptrO = new Operator(lastop);   //отменяем последние два взятия из стека
                    s.push(ptrO);   
                    ptrN = new Number(lastval);
                    s.push(ptrN);   
               }
               else                     //помещаем в стек текущий оператор 
               {
               switch(lastop)        
                  {                  
                  case '+': ptrN = new Number(s.pop()->getNumber() + lastval); s.push(ptrN); break;
                  case '-': ptrN = new Number(s.pop()->getNumber() - lastval); s.push(ptrN); break;
                  case '*': ptrN = new Number(s.pop()->getNumber() * lastval); s.push(ptrN); break;
                  case '/': ptrN = new Number(s.pop()->getNumber() / lastval); s.push(ptrN); break;
                  default:  cout << "\nUnknown oper"; exit(1);
                  }  
               }  
            ptrO = new Operator(pStr[j]);
            s.push(ptrO);              //помещаем в стек текущий оператор 
            }  
         }  
   
      else                           //что-то левое
         { cout << "\nUnknown input character"; exit(1); }
   }
}
//-------------------------------------------------------------
float express::solve ()  //убираем данные из стека
{
    float lastval;              
    while(s.gettop() > 1)
      {
      lastval = s.pop()->getNumber();               //предыдущее значение 
      Number* ptrN;
      switch( s.pop()->getOperator() )              //получение предыдущего оператора
         {                           //do operation, push answer
         case '+': ptrN = new Number(s.pop()->getNumber() + lastval); s.push(ptrN); break;
         case '-': ptrN = new Number(s.pop()->getNumber() - lastval); s.push(ptrN); break;
         case '*': ptrN = new Number(s.pop()->getNumber() * lastval); s.push(ptrN); break;
         case '/': ptrN = new Number(s.pop()->getNumber() / lastval); s.push(ptrN); break;
         default:  cout << "\nUnknown operator"; exit(1);
         }  
      }  
   return float (s.pop()->getNumber());//последний оператор в стеке это результат
}
////////////////////////////////////////////////////////////////
 
int main()
   {
   setlocale (LC_ALL, "russian");
   char ans;            // 'д' или 'н'
   //char stroka [LEN]="12,05+13,05+14,05*2";                          //char from input string
   char stroka [LEN];
   cout << "\nВведите арифметическое выражение в виде 2+3*4/3-2"
          "\nЧисла должны быть из одной цифры"
          "\nНе используйте пробелы и скобки";
 
   do
   {
       cout << "\nВыражение: ";
       cin >> stroka;                          // вводим строку
       express* eptr = new express (stroka);
       eptr->parse();
       cout <<"\nРезультат: "
           << eptr->solve();
       delete eptr;
       cout << "Еще одно выражение (y/n)? ";
    cin >> ans;
   }
   while ( ans == 'y' );
   system("pause");
   return 0;
   }
MA4ETE44
11 / 1 / 1
Регистрация: 06.08.2012
Сообщений: 14
15.10.2013, 12:13     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #90
парни, а решения к 3 главе есть? идет 2ая потом сразу 4ая, или я чего то не увидел
Croessmah
Модератор
Эксперт С++
 Аватар для Croessmah
11837 / 6816 / 771
Регистрация: 27.09.2012
Сообщений: 16,908
Записей в блоге: 2
Завершенные тесты: 1
15.10.2013, 12:15     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #91
Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++"
MA4ETE44
11 / 1 / 1
Регистрация: 06.08.2012
Сообщений: 14
15.10.2013, 19:50     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #92
спс, увидел
Рики
6 / 6 / 1
Регистрация: 27.02.2013
Сообщений: 23
27.10.2013, 04:36     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #93
Глава 12

Задание 12.4
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 <fstream>      // для файловых потоков
#include <iostream>
#include <string>
#include <process.h>      // для exit()
using namespace std;
///////////////////////////////////////////////////////////
class employee            // класс person
  {
  protected:
  public:
    string name;       // имя человека
    string patronymic; //отчество 
    string surname;   //фамилия
    unsigned long No;     // его номер
  
    void getData()      // получить данные о человеке
      {
      cout << "\n  Введите имя: "; cin >> name;
      cout << "  Введите отчество: "; cin >> patronymic;
      cout << "  Введите фамилию: "; cin >> surname;
      cout << "  Введите номер: "; cin >> No;
      }
   // void showData()     // вывод данных о человеке
   //   {
   //   cout << "\n  Имя: "<<name;
      //cout << "\n  Отчество: "<<patronymic;
      //cout << "\n  Фамилия: "<<surname;
   //   cout << "\n  Номер: "<<No;
   //   }
  };
///////////////////////////////////////////////////////////
int main()
  {
  setlocale (LC_ALL, "russian");
  char ch;
  employee worker;          // создать объект person
  ofstream outfile ("workers.txt"); //создать объект ofstream
  do                    // данные от пользователя – в файл
    {
    cout << "Введите данные о работнике:";
    worker.getData();     // получить данные
                        // записать их в файл
    outfile << worker.name
            <<' '
            << worker.patronymic
            <<' '
            << worker.surname
            <<' '
            << worker.No
            <<endl;
    cout << "Файл записан.";
    cout << "Продолжить ввод (y/n)? ";
    cin >> ch;
    }
  while(ch=='y');       // выход по 'n'
  ifstream infile ;
  infile.open("workers.txt");
    if( !infile )           // проверить на наличие ошибок
    {
    cerr << "\nНевозможно открыть workers.txt";
    exit(-1);
    }
  while( infile.get(ch) != 0 ) // считать символ
    cout << ch;                // отобразить символ
 
  
  cout << endl;
  system("pause");
  return 0;
  }

Задание 12.5
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
#include <iostream>
using namespace std;
///////////////////////////////////////////////////////////
class time
{
  private:
    int hrs,mins,secs;
  public:
time():hrs(0),mins(0),secs(0) //конструктор без аргументов
  {}
time(int h,int m,int s):hrs(h),mins(m),secs(s)
  {}//конструктор с тремя аргументами
void get_time()
{
    while (true)
    {
        cout<<"\nчасы: ";
        cin.unsetf(ios::skipws);
        cin>>hrs;
        if (cin.good())
            {
            if(hrs<=23 && hrs>=0)
            {
                cin.ignore(10, '\n');
                break;
            }
            cin.clear();
            cout<<"Значение часов должно лежать между 0 и 23!"<<endl;
            cin.ignore(10, '\n');
            }
        else
            {
            cin.clear();
            cout<<"Неправильно введены часы."<<endl;
            cin.ignore(10, '\n');
            }
    }
    while (true)
    {
        cout<<"минуты: ";
        cin.unsetf(ios::skipws);
        cin>>mins;
        if (cin.good())
        {
            if(mins<=60 && mins>=0)
            {
                cin.ignore(10, '\n');
                break;
            }
            cin.clear();
            cout<<"Значение минут должно лежать между 0 и 60!"<<endl;
            cin.ignore(10, '\n');
        }
        else
        {
            cin.clear();
            cout<<"Неправильно введены минуты."<<endl;
            cin.ignore(10, '\n');
        }
    }
    while (true)
    {
        cout<<"секунды: ";
        cin.unsetf(ios::skipws);
        cin>>secs;
        if (cin.good())
        {
            if(secs<=60 && secs>=0)
            {
                cin.ignore(10, '\n');
                break;
            }
            cin.clear();
            cout<<"Значение ctreyl должно лежать между 0 и 60!"<<endl;
            cin.ignore(10, '\n');
        }
        else
        {
            cin.clear();
            cout<<"Неправильно введены секунды."<<endl;
            cin.ignore(10, '\n');
        }
    }
    }
void put_time()const           //формат 11:59:59
{
    cout <<hrs <<":";
    if (mins<10)
        cout<<"0"<<mins<<":";
    else
        cout<<mins<<":";
    if (secs<10)
        cout<<"0"<<secs;
    else
        cout<<secs;
    cout<<endl;
}
   
};
///////////////////////////////////////////////////////////
int main()
{
    setlocale (LC_ALL, "russian");
    time t1;
    char ch;
    do                    // данные от пользователя – в файл
    {
        cout<<"Введите время в формате 12:59:59 "<<endl;
        t1.get_time();     // получить данные
        t1.put_time();
        cout << "Продолжить ввод (y/n)? ";
        cin >> ch;
    }
    while(ch=='y');       // выход по 'n'
    cout <<endl;
    system("pause");
    return 0;
}

Задание 12.6
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
#include <fstream>      // для файловых потоков
#include <iostream>
#include <string>
#include <process.h>      // для exit()
//#include <stdio.h>
//#include <stdlib.h>
using namespace std;
const int IDN = 5;
///////////////////////////////////////////////////////////
class names            // класс person
  {
  protected:
    string name;       // имя человека
    string patronymic; //отчество 
    string surname;   //фамилия
    unsigned long No;     // его номер
 
  public:
      void getData()      // получить данные о человеке
      {
      cout << "\n  Введите имя: "; cin >> name;
      cout << "  Введите отчество: "; cin >> patronymic;
      cout << "  Введите фамилию: "; cin >> surname;
      cout << "  Введите номер: "; cin >> No;
      }
    void write()
    {
        ofstream outfile ("name.txt"); //создать объект ofstream
        outfile <<name
            <<' '
            <<patronymic
            <<' '
            <<surname
            <<' '
            <<No
            <<endl;
        outfile.close();
        cout << "Файл записан.";
    }
    void read(char* id)
    {
        const int MAX = 100;
        char buffer[MAX];
 
        //char ch;
        ifstream infile ;
        infile.open("workers.txt");
        if( !infile )           // проверить на наличие ошибок
        {
            cerr << "\nНевозможно открыть workers.txt";
            exit(-1);
        }
        //while( infile.get(ch) != 0 ) // считать символ
        //  cout << ch;                // отобразить символ
        while( !infile.eof())
        {
            infile.getline(buffer, MAX);
            for(int j=0; j<100; j++)
            {
                if(buffer[j]==id[0] && buffer[j+1]==id[1] &&
                   buffer[j+2]==id[2] && buffer[j+3]==id[3])
                {
                    cout<<buffer<<endl;
                    system("pause");
                    exit(1);
                }
                else if(buffer[j]=='\0')
                    break;
            }
            for(int j=0; j<100; j++)
                buffer[j]=0;
        }
        cout << "\n  Таких людей нет.";
 
    }
    void showData()     // вывод данных о человеке
    {
      cout << "\n  Имя: "<<name;
      cout << "\n  Отчество: "<<patronymic;
      cout << "\n  Фамилия: "<<surname;
      cout << "\n  Номер: "<<No;
    }
  };
///////////////////////////////////////////////////////////
int main()
  {
  setlocale (LC_ALL, "russian");
  char ch;
  char id[IDN];
  names worker;          // создать объект person
 
  do                    // данные от пользователя – в файл
    {
    cout << "Введите данные о работнике:";
    worker.getData();     // получить данные
    worker.write();         // записать их в файл
    
    cout << "Продолжить ввод (y/n)? ";
    cin >> ch;
    }
  while(ch=='y');       // выход по 'n'
  while (true)
    {
        cout<<"Введите номер сотрудника (1234): ";
        cin.unsetf(ios::skipws);
        cin.get(id,IDN);
        if (cin.good())
        {
            if(strlen(id)<=4 && strlen(id)>=0)
            {
                cin.ignore(10, '\n');
                break;
            }
            cin.clear();
            cout<<"Номер сотрудника должен быть четырехзначным!"<<endl;
            cin.ignore(10, '\n');
        }
        else
        {
            cin.clear();
            cout<<"Неправильно введен номер."<<endl;
            cin.ignore(10, '\n');
        }
    }
  worker.read(id);
 
  cout << endl;
  system("pause");
  return 0;
  }

Задание 12.7 (12.12)
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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
#include <fstream>      // для файловых потоков
#include <iostream>
#include <string>
#include <process.h>      // для exit()
//#include <stdio.h>
//#include <stdlib.h>
const int IDN = 5;
const int MAXEM = 100;  // максимальное число людей
using namespace std;
///////////////////////////////////////////////////////////
class names            // класс person
  {
  protected:
    string name;       // имя человека
    string patronymic; //отчество 
    string surname;   //фамилия
    static int n;    // текущее число людей
    static names* arrap[]; //массив указателей на
                              // класс работников
    unsigned long No;     // его номер
 
  public:
      void getData()      // получить данные о человеке
      {
          cout << "\n  Введите имя: "; cin >> name;
          cout << "  Введите отчество: "; cin >> patronymic;
          cout << "  Введите фамилию: "; cin >> surname;
          cout << "  Введите номер: "; cin >> No;
      }
      void showData()     // вывод данных о человеке
      {
          cout << "\n  Имя: "<<name;
          cout << "\n  Отчество: "<<patronymic;
          cout << "\n  Фамилия: "<<surname;
          cout << "\n  Номер (XXXX): "<<No;
      }
    void write_format()
    {
        ofstream outfile ("name.txt"); //создать объект ofstream
        outfile <<name
            <<' '
            <<patronymic
            <<' '
            <<surname
            <<' '
            <<No
            <<endl;
        outfile.close();
        cout << "Файл записан.";
    }
    static void read_specific();
    static void add();
    static void Display();
    static void write();
    static void read();
  };
//---------------------------------------------------------
void names::read_specific()
    {
    const int MAX = 100;
    char buffer[MAX];
    char id[IDN];
    while (true)
    {
        cout<<"Введите номер сотрудника (1234): ";
        cin.unsetf(ios::skipws);
        cin.get(id,IDN);
        if (cin.good())
        {
            if(strlen(id)<=4 && strlen(id)>=0)
            {
                cin.ignore(10, '\n');
                break;
            }
            cin.clear();
            cout<<"Номер сотрудника должен быть четырехзначным!"<<endl;
            cin.ignore(10, '\n');
        }
        else
        {
            cin.clear();
            cout<<"Неправильно введен номер."<<endl;
            cin.ignore(10, '\n');
        }
    }
    ifstream infile ;
    infile.open("names.txt");
    if( !infile )           // проверить на наличие ошибок
    {
        cerr << "\nНевозможно открыть workers.txt";
        exit(-1);
    }
    while( !infile.eof())
    {
        infile.getline(buffer, MAX);
        for(int j=0; j<100; j++)
        {
            if(buffer[j]==id[0] && buffer[j+1]==id[1] &&
               buffer[j+2]==id[2] && buffer[j+3]==id[3])
            {
                cout<<buffer<<endl;
                system("pause");
                exit(1);
            }
            else if(buffer[j]=='\0')
                break;
        }
        for(int j=0; j<100; j++)
            buffer[j]=0;
    }
    cout << "\n  Таких людей нет.";
}
//---------------------------------------------------------
//статические переменные
int names::n;                  // текущее число работников
names* names::arrap[MAXEM]; // массив указателей на
                                  // класс работников
//---------------------------------------------------------
//добавить человека  в список (хранится в ОП)
void names::add()
  { arrap[n] = new names; 
  arrap[n++]->getData();  //Получить данные от пользователя
  }
//---------------------------------------------------------
//Вывести данные обо всех людях
void names::Display()
  {
  for(int j=0; j<n; j++)
    {
    cout<<(j+1);                // вывести номер
    arrap[j]->showData();           // Вывод данных
    cout<<endl;
    }
  }
//---------------------------------------------------------
//Записать все объекты, хранящиеся в памяти, в файл
void names::write()
  {
 
  cout<<"Идет запись " << n << " работников.\n";
  ofstream ouf;           // открыть ofstream в двоичном виде
  ouf.open("names.txt");
  if(!ouf)
    { cout<<"\nНевозможно открыть файл\n"; return; }
  for(int j=0; j<n; j++)
  {
      ouf <<arrap[j]->name
            <<' '
            <<arrap[j]->patronymic
            <<' '
            <<arrap[j]->surname
            <<' '
            <<arrap[j]->No;
      if (j<n-1)         
          ouf<<endl;
  }
 
      //ouf.write(reinterpret_cast<char*>(&arrap[j]), sizeof(arrap[j]) );
      //ouf.write((char*)(arrap[j]), sizeof(arrap[j]) );
    if(!ouf)
      { cout<<"\nЗапись в файл невозможна\n"; return; }
    }
//---------------------------------------------------------
//чтение всех данных из файла в память
void names::read()
{
  ifstream inf;           // открыть ifstream в двоичном виде
  inf.open("names.txt");
  if(!inf)
    { cout << "\nНевозможно открыть файл\n"; return; }
  n = 0;                  // В памяти работников нет
  while(true)
  {
      if(inf.eof())
          break;
      if(!inf)              // ошибка чтения типа
      { cout << "\nНевозможно чтение типа\n"; return; }
      arrap[n] = new names;
      inf>>arrap[n]->name>>arrap[n]->patronymic>>arrap[n]->surname>>arrap[n]->No;
      
      if(!inf)              // ошибка, но не EOF
      { cout << "\nЧтение данных из файла невозможно\n"; return; }
      n++;                  // счетчик работников увеличить
  }
  cout << "Идет чтение " << n << " работников\n";
}
///////////////////////////////////////////////////////////
int main()
  {
  setlocale (LC_ALL, "russian");
  char ch;
  
  //names worker;          // создать объект person
 
   while(true)
    {
    cout << "'a' – добавление сведений о работнике"
          "\n'd' - вывести сведения обо всех работниках"
          "\n'w' – записать все данные в файл"
          "\n'r' – прочитать все данные из файла"
          "\n'f' – найти определенного работника"
          "\n'x' - выход"
          "\nВаш выбор: ";
    cin >> ch;
    switch(ch)
      {
      case 'a':           // добавить работника
        names::add(); break;
      case 'd':           // вывести все сведения
        names::Display(); break;
      case 'w':           // запись в файл
        names::write(); break;
      case 'r':           // чтение всех данных из файла
        names::read(); break;
      case 'f':           // чтение всех данных из файла
        names::read_specific(); break;
      case 'x': exit(0);  // выход
      default: cout << "\nНеизвестная команда";
      }  //end switch
    }  //end while
  
 
  cout << endl;
  system("pause");
  return 0;
  }

Задание 12.8
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
#include <iostream>
#include <fstream>      // для файловых потоков
using namespace std;
///////////////////////////////////////////////////////////
struct link   // один элемент списка
{
  int data;   // некоторые данные
  link* next; // указатель на следующую структуру
};
///////////////////////////////////////////////////////////
class linklist // список
{
  private:
    link* first;
    static int n;
  public:
    linklist ( )            // конструктор без параметров
      { first = NULL; n = 0; }     // первого элемента пока нет
    ~linklist();
    void additem ( ); // добавление элемента
    void display ( );       // показ данных
    void read ( );
    void write ( );
};
///////////////////////////////////////////////////////////
int linklist::n;  
///////////////////////////////////////////////////////////
void linklist::additem (  ) // добавление элемента
{
  int d;
  cout<<"Введите число ";
  cin>>d;
  link* newlink = new link;      // выделяем память
  newlink->data = d;             // запоминаем данные
  newlink->next = first;         // запоминаем значение first
  first = newlink;               // first теперь указывает на новый элемент
  n++;
}
///////////////////////////////////////////////////////////
void linklist::display ( )
{
  link* current = first;           // начинаем с первого элемента
  while( current )                 // пока есть данные
  {
    cout << current->data << endl; // печатаем данные
    current = current->next;       // двигаемся к следующему элементу
  }
}
///////////////////////////////////////////////////////////
void linklist::read ( )
{
 ifstream inf;           // открыть ifstream в двоичном виде
  inf.open("12.8.txt");
  if(!inf)
    { cout << "\nНевозможно открыть файл\n"; return; }
  n = 0; 
  first = NULL;
  while(true)
  {
      if(inf.eof())
          break;
      if(!inf)              // ошибка чтения типа
      { cout << "\nНевозможно чтение типа\n"; return; }
      link* newlink = new link;      // выделяем память
      inf>>newlink->data;             // запоминаем данные
      newlink->next = first;         // запоминаем значение first
      first = newlink;               // first теперь указывает на новый элемент
      //inf>>arrap[n]->name>>arrap[n]->patronymic>>arrap[n]->surname>>arrap[n]->No;
      
      if(!inf)              // ошибка, но не EOF
      { cout << "\nЧтение данных из файла невозможно\n"; return; }
      n++; 
  }
  cout << "Идет чтение "<<n<<" объектов"<<endl;
}
///////////////////////////////////////////////////////////
void linklist::write ( )
{
  cout<<"Идет запись "<<n<<" объектов"<<endl;
  ofstream ouf;           // открыть ofstream в двоичном виде
  ouf.open("12.8.txt");
  if(!ouf)
    { cout<<"\nНевозможно открыть файл\n"; return; }
  link* current = first;           // начинаем с первого элемента
  for(int j=0; j<n; j++)                // пока есть данные
  {
    ouf << current->data;          // печатаем данные
    if (j<n-1)       
          ouf<<endl;
    current = current->next;       // двигаемся к следующему элементу
  }
}
///////////////////////////////////////////////////////////
linklist::~linklist()
    {
        link*current =first;   //установить указатель на первый элемент
        while(current !=NULL ) //выход по достижении последнего элемента
        {
            link*temp =current;  //сохранить указатель на данный элемент
            current =current->next;  //получить ссылку на следующую ссылку
            delete temp;               //удалить эту ссылку
      }
    }
 
///////////////////////////////////////////////////////////
int main ( )
{
  setlocale (LC_ALL, "russian");
  linklist li, li2;       // создаем переменную-список
  char ch;
 
  while(true)
    {
    cout << "'a' – добавить ссылку в список"
          "\n's' - показать данные по всем ссылкам из списка"
          "\n'w' – записать в файл данные для всех ссылок"
          "\n'r' – считать все данные из файла и создать новый список"
          "\n'x' - выход"
          "\nВаш выбор: ";
    cin >> ch;
    switch(ch)
      {
      case 'a':           // добавить работника
        li.additem(); break;
      case 's':           // вывести все сведения
        li.display(); break;
      case 'w':           // запись в файл
        li.write(); break;
      case 'r':           // чтение всех данных из файла
        li.~linklist(); li.read(); break;
      case 'x': exit(0);  // выход
      default: cout << "\nНеизвестная команда";
      }  //end switch
   }  //end while
  cout << endl;
 
 
 
  //li.additem ( 25 ); // добавляем туда несколько чисел
  //li.additem ( 36 );
  //li.additem ( 49 );
  //li.additem ( 64 );
 
  //li.display ( );    // показываем список
 
 
 
  system("pause");
  return 0;
}

Задание 12.9
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
#include<iostream>
#include<cmath>
using namespace std;
////////////////////////////////////////////////////////////////////////////////
class fraction
{
   private:
      int chis, znam;
   public:
      fraction(): chis(0), znam(0)
        {}
      fraction(int c, int z): chis(c), znam(z)
        {}
 
      fraction operator+ (fraction);
      fraction operator- (fraction);
      fraction operator/ (fraction);
      fraction operator* (fraction);
      bool operator== (fraction);
      bool operator!= (fraction);
      fraction lowterms (); 
      friend istream& operator >> (istream& s, fraction& f);
      friend ostream& operator << (ostream& s, fraction& f);
};
//------------------------------------------------------------------------------
fraction fraction::operator+ (fraction f2)
    {
        fraction f1;
        f1.chis = (chis*f2.znam+znam*f2.chis);
        f1.znam = (znam*f2.znam);  
        return f1.lowterms();
    }
//------------------------------------------------------------------------------
fraction fraction::operator- (fraction f2)
    {
        fraction f1;
        f1.chis = (chis*f2.znam-znam*f2.chis);
        f1.znam = (znam*f2.znam);
        return f1.lowterms();
    }
//------------------------------------------------------------------------------
fraction fraction::operator* (fraction f2)
    {
        fraction f1;
        f1.chis = (chis*f2.chis);
        f1.znam = (znam*f2.znam);
        return f1.lowterms();
    }
//------------------------------------------------------------------------------
fraction fraction::operator/ (fraction f2)
    {
        fraction f1;
        f1.chis = (chis*f2.znam);
        f1.znam = (znam*f2.chis);
        return f1.lowterms();
    }
//------------------------------------------------------------------------------
bool fraction::operator== (fraction f2)
    {
        return (chis == f2.chis && znam==f2.znam )? true : false;
    }
//------------------------------------------------------------------------------
bool fraction::operator!= (fraction f2)
    {
        return (chis != f2.chis && znam!=f2.znam )? true : false;
    }
//------------------------------------------------------------------------------
fraction fraction::lowterms ()
    {
        fraction f1;               
        long tchis, tznam, temp, gcd;
        tchis = labs(chis);
        tznam = labs(znam);
        if (tznam == 0)
            { cout<<"Недопустимый знаменатель!"; exit(1);}
        else if (tchis == 0)
            { chis = 0; znam = 1; return fraction (chis, znam);;}
        while(tchis !=0)
            {
                if(tchis < tznam)
                    {temp = tchis; tchis = tznam; tznam = temp;}
                tchis = tchis - tznam;
            }
        gcd = tznam;
        chis = chis/gcd;
        znam = znam/gcd;
        return fraction (chis, znam);
 
    }
////////////////////////////////////////////////////////////////////////////////
istream& operator >> (istream& s, fraction& f)
    {
    char drob; 
    cout<< "Введите значение дроби в формате x/y: "<<endl;
    s>>f.chis>>drob>>f.znam;
    return s;
    }
////////////////////////////////////////////////////////////////////////////////
ostream& operator << (ostream& s, fraction& f)
    {
    s<<f.chis<<"/"<<f.znam;
    return s;
    }
////////////////////////////////////////////////////////////////////////////////
int main()
{
setlocale (LC_ALL, "russian");
fraction d1, d2, d3, wrong1 (0, 1);  
 
char ch;  
do
    {
       char operacia; 
       cin>> d1;
       if (d1==wrong1)
       {
           cout << "Неверный формат дроби "<<endl; 
           break;
       }
       cout<< "Введите операцию: *,/,+,-."<<endl;
       cin>>operacia;
       cin>> d2;
       switch(operacia)
       {
            case '/': cout<<(d3=d1/d2);break;  
            case '*': cout<<(d3=d1*d2); break;                   
            case '+': cout<<(d3=d1+d2); break;      
            case '-': cout<<(d3=d1-d2); break;    
        }
       cout << "\n Еще раз?(y/n):  "; 
       cin>>ch;
    }        
while (ch != 'n');
system("pause");
return 0;
}

Задание 12.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
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
#include<iostream>
#include<cmath>
using namespace std;
////////////////////////////////////////////////////////////////////////////////
class fraction
{
   private:
      int chis, znam;
   public:
      fraction(): chis(0), znam(0)
        {}
      fraction(int c, int z): chis(c), znam(z)
        {}
 
      fraction operator+ (fraction);
      fraction operator- (fraction);
      fraction operator/ (fraction);
      fraction operator* (fraction);
      bool operator== (fraction);
      bool operator!= (fraction);
      fraction lowterms (); 
      friend istream& operator >> (istream& s, fraction& f);
      friend ostream& operator << (ostream& s, fraction& f);
};
//------------------------------------------------------------------------------
fraction fraction::operator+ (fraction f2)
    {
        fraction f1;
        f1.chis = (chis*f2.znam+znam*f2.chis);
        f1.znam = (znam*f2.znam);  
        return f1.lowterms();
    }
//------------------------------------------------------------------------------
fraction fraction::operator- (fraction f2)
    {
        fraction f1;
        f1.chis = (chis*f2.znam-znam*f2.chis);
        f1.znam = (znam*f2.znam);
        return f1.lowterms();
    }
//------------------------------------------------------------------------------
fraction fraction::operator* (fraction f2)
    {
        fraction f1;
        f1.chis = (chis*f2.chis);
        f1.znam = (znam*f2.znam);
        return f1.lowterms();
    }
//------------------------------------------------------------------------------
fraction fraction::operator/ (fraction f2)
    {
        fraction f1;
        f1.chis = (chis*f2.znam);
        f1.znam = (znam*f2.chis);
        return f1.lowterms();
    }
//------------------------------------------------------------------------------
bool fraction::operator== (fraction f2)
    {
        return (chis == f2.chis && znam==f2.znam )? true : false;
    }
//------------------------------------------------------------------------------
bool fraction::operator!= (fraction f2)
    {
        return (chis != f2.chis && znam!=f2.znam )? true : false;
    }
//------------------------------------------------------------------------------
fraction fraction::lowterms ()
    {
        fraction f1;               
        long tchis, tznam, temp, gcd;
        tchis = labs(chis);
        tznam = labs(znam);
        if (tznam == 0)
            { cout<<"Недопустимый знаменатель!"; exit(1);}
        else if (tchis == 0)
            { chis = 0; znam = 1; return fraction (chis, znam);;}
        while(tchis !=0)
            {
                if(tchis < tznam)
                    {temp = tchis; tchis = tznam; tznam = temp;}
                tchis = tchis - tznam;
            }
        gcd = tznam;
        chis = chis/gcd;
        znam = znam/gcd;
        return fraction (chis, znam);
 
    }
////////////////////////////////////////////////////////////////////////////////
istream& operator >> (istream& s, fraction& f)
    {
    char drob; 
    cout<< "Введите значение дроби в формате x/y: "<<endl;
    //s.ignore(10, '\n');
    while (true)
    {
        s.unsetf(ios::skipws);
        s>>f.chis>>drob>>f.znam;
        if (s.good())
            {
            if(f.znam!=0)
            {
                s.ignore(10, '\n');
                break;
            }
            s.clear();
            cout<<"Знаменатель не может быть нулевым!"<<endl;
            cout<<"Введите дробь заново: ";
            s.ignore(10, '\n');
            }
        else
            {
            s.clear();
            cout<<"Ошибка ввода."<<endl;
            cout<<"Введите дробь заново: ";
            s.ignore(10, '\n');
            }
    }
    return s;
    }
////////////////////////////////////////////////////////////////////////////////
ostream& operator << (ostream& s, fraction& f)
    {
    s<<f.chis<<"/"<<f.znam;
    return s;
    }
////////////////////////////////////////////////////////////////////////////////
int main()
{
setlocale (LC_ALL, "russian");
fraction d1, d2, d3, wrong1 (0, 1);  
 
char ch;  
do
    {
       char operacia; 
       cin>> d1;
       cout<< "Введите операцию: *,/,+,-."<<endl;
       cin>>operacia;
       cin.ignore(10, '\n');
       cin>> d2;
       switch(operacia)
       {
            case '/': cout<<"Ответ ---------------"<<(d3=d1/d2); break;  
            case '*': cout<<"Ответ ---------------"<<(d3=d1*d2); break;                   
            case '+': cout<<"Ответ ---------------"<<(d3=d1+d2); break;      
            case '-': cout<<"Ответ ---------------"<<(d3=d1-d2); break;    
        }
       cout << "\n Еще раз?(y/n):  "; 
       cin>>ch;
       cin.ignore(10, '\n');
    }        
while (ch != 'n');
system("pause");
return 0;
}

Задание 12.11
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
#include<iostream>
#include<cmath>
using namespace std;
////////////////////////////////////////////////////////////////////////////////
class fraction
{
   private:
      int chis, znam;
   public:
      fraction(): chis(0), znam(0)
        {}
      fraction(int c, int z): chis(c), znam(z)
        {}
 
      fraction operator+ (fraction);
      fraction operator- (fraction);
      fraction operator/ (fraction);
      fraction operator* (fraction);
      bool operator== (fraction);
      bool operator!= (fraction);
      fraction lowterms (); 
      friend istream& operator >> (istream& s, fraction& f);
      friend ostream& operator << (ostream& s, fraction& f);
};
//------------------------------------------------------------------------------
fraction fraction::operator+ (fraction f2)
    {
        fraction f1;
        f1.chis = (chis*f2.znam+znam*f2.chis);
        f1.znam = (znam*f2.znam);  
        return f1.lowterms();
    }
//------------------------------------------------------------------------------
fraction fraction::operator- (fraction f2)
    {
        fraction f1;
        f1.chis = (chis*f2.znam-znam*f2.chis);
        f1.znam = (znam*f2.znam);
        return f1.lowterms();
    }
//------------------------------------------------------------------------------
fraction fraction::operator* (fraction f2)
    {
        fraction f1;
        f1.chis = (chis*f2.chis);
        f1.znam = (znam*f2.znam);
        return f1.lowterms();
    }
//------------------------------------------------------------------------------
fraction fraction::operator/ (fraction f2)
    {
        fraction f1;
        f1.chis = (chis*f2.znam);
        f1.znam = (znam*f2.chis);
        return f1.lowterms();
    }
//------------------------------------------------------------------------------
bool fraction::operator== (fraction f2)
    {
        return (chis == f2.chis && znam==f2.znam )? true : false;
    }
//------------------------------------------------------------------------------
bool fraction::operator!= (fraction f2)
    {
        return (chis != f2.chis && znam!=f2.znam )? true : false;
    }
//------------------------------------------------------------------------------
fraction fraction::lowterms ()
    {
        fraction f1;               
        long tchis, tznam, temp, gcd;
        tchis = labs(chis);
        tznam = labs(znam);
        if (tznam == 0)
            { cout<<"Недопустимый знаменатель!"; exit(1);}
        else if (tchis == 0)
            { chis = 0; znam = 1; return fraction (chis, znam);;}
        while(tchis !=0)
            {
                if(tchis < tznam)
                    {temp = tchis; tchis = tznam; tznam = temp;}
                tchis = tchis - tznam;
            }
        gcd = tznam;
        chis = chis/gcd;
        znam = znam/gcd;
        return fraction (chis, znam);
 
    }
////////////////////////////////////////////////////////////////////////////////
istream& operator >> (istream& s, fraction& f)
    {
    char drob; 
    cout<< "Введите значение дроби в формате x/y: "<<endl;
    //s.ignore(10, '\n');
    while (true)
    {
        s.unsetf(ios::skipws);
        s>>f.chis>>drob>>f.znam;
        if (s.good())
            {
            if(f.znam!=0)
            {
                s.ignore(10, '\n');
                break;
            }
            s.clear();
            cout<<"Знаменатель не может быть нулевым!"<<endl;
            cout<<"Введите дробь заново: ";
            s.ignore(10, '\n');
            }
        else
            {
            s.clear();
            cout<<"Ошибка ввода."<<endl;
            cout<<"Введите дробь заново: ";
            s.ignore(10, '\n');
            }
    }
    return s;
    }
////////////////////////////////////////////////////////////////////////////////
ostream& operator << (ostream& s, fraction& f)
    {
    s<<f.chis<<"/"<<f.znam;
    return s;
    }
////////////////////////////////////////////////////////////////////////////////
int main()
{
setlocale (LC_ALL, "russian");
fraction d1, d2, d3, wrong1 (0, 1);  
 
char ch;  
do
    {
       char operacia; 
       cin>> d1;
       cout<< "Введите операцию: *,/,+,-."<<endl;
       cin>>operacia;
       cin.ignore(10, '\n');
       cin>> d2;
       switch(operacia)
       {
            case '/': cout<<"Ответ ---------------"<<(d3=d1/d2); break;  
            case '*': cout<<"Ответ ---------------"<<(d3=d1*d2); break;                   
            case '+': cout<<"Ответ ---------------"<<(d3=d1+d2); break;      
            case '-': cout<<"Ответ ---------------"<<(d3=d1-d2); break;    
        }
       cout << "\n Еще раз?(y/n):  "; 
       cin>>ch;
       cin.ignore(10, '\n');
    }        
while (ch != 'n');
system("pause");
return 0;
}


ps Парни, выкладывайте пожалуйста свои задания. Интересно же, хочется посмотреть.
Scythian
 Аватар для Scythian
58 / 58 / 8
Регистрация: 01.01.2010
Сообщений: 222
29.10.2013, 00:20     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #94
ГЛАВА 7 ЗАДАЧА 7

Хочу поделиться своим вариантом. Мне кажется он лаконичней и более универсален.

Кликните здесь для просмотра всего текста
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
#include<iostream>
#include<stdlib.h>
#include<string>
#include<iomanip>
using namespace std;
 
class money
{
private:
    long double denughka;
public:
    money(){};
    void mstold(string st)
    {
        string m="0123456789.";
        int pos=0,l=0;
        while(pos>=0)
        {
            pos=st.find_first_not_of(m);
            if(pos==-1)
                break;
            st.replace(pos,1,"");
        }
        denughka=atof(st.c_str());
    }
    void show()
    {
        cout<<setiosflags(ios::fixed)<<setprecision(2)<<endl<<denughka<<endl;
    }
};
int main()
{
    money d;
    string s;
    char ch='Y';
    while(ch!='N')
    {
        cout<<"Enter the sum\t";
        cin>>s;
        d.mstold(s);
        d.show();
        cout<<"\nto continue?(Y/N)";
        cin>>ch;
    }
    system("pause");
    return 0;
}
ForEveR
Модератор
Эксперт C++
 Аватар для ForEveR
7927 / 4709 / 318
Регистрация: 24.06.2010
Сообщений: 10,524
Завершенные тесты: 3
29.10.2013, 10:43     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #95
7.7 как-то так. Просто ради развлечения.
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
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
 
class money
{
public:
   money(const std::string& value) : amount_(convert(value))
   {
   }
   long double get() const
   {
      return amount_;
   }
   void set(const std::string& value)
   {
      amount_ = convert(value);
   }
private:
   long double convert(std::string value)
   {
      static auto finder = [] (const char c)
      {
         return (!isdigit(c) && c != '.');
      };
      value.erase(std::remove_if(value.begin(), value.end(), finder), value.end());
      long double amount = 0.;
      std::stringstream ss(value);
      ss >> amount;
      return amount;
   }
   long double amount_;
};
 
std::ostream& operator << (std::ostream& os, const money& m)
{
   return (os << std::fixed << std::setprecision(2) << m.get());
}
 
int main()
{
   money m("$1,234,567,890,123.99");
   std::cout << m << std::endl;
}
halmikar
0 / 0 / 0
Регистрация: 31.10.2013
Сообщений: 3
01.11.2013, 06:06     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #96
не нашел главы 6
Застрял на 8 задаче
так только нули выводит

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
#include <iostream>
 
using namespace std;
 
class count
{
private:
    static int temp;
    int number;
public:
    count() : number(1) 
    {}
    void Counter()
    {
        temp++;
        number+= temp;
    }
    void display()
    {
        cout << "№"<< number << endl;
    }
};
int main()
{
    count c1, c3, c2;
    c1.display();
    c2.display();
    c3.display();
    system("PAUSE");
    return 0;
}
Подскажите где неверно
Рики
6 / 6 / 1
Регистрация: 27.02.2013
Сообщений: 23
01.11.2013, 17:43     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #97
Шестая глава
MA4ETE44
11 / 1 / 1
Регистрация: 06.08.2012
Сообщений: 14
07.11.2013, 16:54     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #98
уважаемые, у кого-нибудь были проблемы с примерами в 5 главе задачи circstrc.cpp? не могу скомпилить все это дело, добавил 2а файла что приложены в приложении Д, ничего хорошего...
Tiki-Tiki
0 / 0 / 0
Регистрация: 07.11.2013
Сообщений: 3
07.11.2013, 23:49     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #99
в 12.7 мне кажется криво работает метод read_specific.Или я не понимаю как он работает...

Добавлено через 3 минуты
Цитата Сообщение от MA4ETE44 Посмотреть сообщение
уважаемые, у кого-нибудь были проблемы с примерами в 5 главе задачи circstrc.cpp? не могу скомпилить все это дело, добавил 2а файла что приложены в приложении Д, ничего хорошего...
С какими конкретно задачами беда?
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
08.11.2013, 00:09     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++"
Еще ссылки по теме:

Объектно-ориентированное программирование C++
Разобраться в примерх к книге Лафоре "Обьектно-ориентированое программирование в С++" C++
C++ Объектно-ориентированное приложение: "Эмулятор банкомата"

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

Или воспользуйтесь поиском по форуму:
Sabbat
 Аватар для Sabbat
135 / 23 / 1
Регистрация: 19.10.2012
Сообщений: 43
08.11.2013, 00:09     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++" #100
Цитата Сообщение от Kins Посмотреть сообщение
Глава 9 Упражнение №8
Кликните здесь для просмотра всего текста
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
using namespace std;
 
////////////////////////////////////////////////////////////////
class String
{
protected:
    static const int SZ=18;//максимальный размер строки
    char str[SZ];//сама строка
public:
    String()//конструктор без параметров
    {str[0]='\x0';}
    String(char s[])//конструктор с одним параметром
    {strcpy_s(str, s);}
    void display()//показ строки
    {
        cout <<str <<endl;
    }
    //перевод строки к обычному типу
    operator char*()
    {return str;}
};
///////////////////////////////////////////////////////////////
class Pstring:public String
{
public:
    Pstring():String()
    {}
    Pstring(char s[])
    {
        if(strlen(s)<SZ){
            strcpy_s(str, s);}
        if(strlen(s)>=SZ){
            for(int j=0; j<SZ; j++){
                if(j==(SZ-1)){
                    str[j]='\0';
                    continue;
                }
                str[j]=s[j];                
            }
        }
    }
    void display()
    {String::display();}
};
///////////////////////////////////////////////////////////////
class Pstring2: public Pstring
{
private:
    int number;//номер символа
    char simbol;//символ строки
public:
    Pstring2():Pstring()
    {}
    Pstring2(char s[]):Pstring(s)
    {}
    Pstring2& left(Pstring p2, int number)//в строку s2 помещаются n самых левых символов строки s1
    {
        for(int j=0; j<=number; j++){
            str[j]=p2[j];
            if(j==number){
                str[j]='\0';
            }
        }
        return Pstring2(str);
    }
    Pstring2& mid(Pstring p2, char sl, int n)//в строку s2 помещаются n символов строки s1 начиная с символа s
    {
        for(int j=0; j<strlen(p2); j++){
            if(p2[j]!=sl){
                continue;
            }else{
                for(int i=0; i<=n; i++){
                    str[i]=p2[j+i];
                    if(i==n){
                        str[i]='\0';
                        break;
                    }
                }
            }
        }
        return Pstring2(str);
    }
    Pstring2& right(Pstring p2, int n)//в строку s2 помещаются n самых правых символов строки s1
    {
        int t=strlen(p2)-n;
        for(int j=0; j<=strlen(p2); j++){
            str[j]=p2[j+t];
            if(j==strlen(p2)){
                str[j]='\0';
            }
        }
        return Pstring2(str);
    }
};
///////////////////////////////////////////////////////////////
int _tmain(int argc, _TCHAR* argv[])
{
    setlocale(LC_ALL,"");
    Pstring s, s1;
    s="Шла саша по шоссе";  
    s.display();
    s1="Асталависта бэйби нау";
    s1.display();
    Pstring2 s2, s3, s4;
    s3.left(s1, 5);//пять символов слева
    s3.display();
    s2=s3.mid(s1, 'в', 7);//семь символов начиная с символа 'в'
    s2.display();
    s4.right(s1, 9);//девять крайних правых символов
    s4.display();
    cout <<endl;
    system("pause");
    return 0;
}
кстати в функции mid(), там же вроде с номера символа а не из самого значения символа, если я правильно понял?
у меня только в студии компилирует и больше ни в чем(CodeBlocks,Dev-C++)
ругается на return Pstring2(str);
Цитата Сообщение от CodeBlocks
C:\Program Files (x86)\CodeBlocks\work\work.cpp|64|error: invalid initialization of non-const reference of type 'Pstring2&' from an rvalue of type 'Pstring2'|
кто-то ещё делал?
Yandex
Объявления
08.11.2013, 00:09     Решение всех упражнений из книги Р. Лафоре "Объектно-ориентированное программирование в С++"
Ответ Создать тему
Опции темы

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