2.3. Вход и изход

Програма Zad1.cpp намира периметъра и лицето само на правоъгълник със страни 2.3 и 3.7. Нека решим тази задача в общия случай.
Задача 2. Да се напише програма, която въвежда размерите на правоъгълник и намира периметъра и лицето му.

Програмата Zad2.cpp решава тази задача.
Program Zad2.cpp
#include <iostream.h>
int main()
{// въвеждане на едната страна
cout << "a= ";
double a;
cin >> a;
// въвеждане на другата страна
cout << "b= ";
double b;
cin >> b;
// намиране на периметъра
double p;
p = 2*(a+b);
// намиране на лицето
double s;
s = a*b;
// извеждане на периметъра
cout << "p= " << p << "\n";
// извеждане на лицето
cout << "s= " << s << "\n";
return 0;
}
Когато програмата бъде стартирана, върху екрана ще се появи подсещането
a=
което е покана за въвеждане размерите на едната страна на правоъгълника. Курсорът стои след знака =. Очаква се да бъде въведено число (цяло или реално), след което да бъде натиснат клавишът ENTER.
Следва покана за въвеждане на стойност за другата страна на правоъгълника, след което програмата ще изведе резултата и ще завърши изпълнението си.
Въвеждането на стойността на променливата a се осъществява с оператора за вход
cin >> a;
Обектът cin е името на стандартния входен поток, обикновено клавиатурата на компютъра. Изпълнението му води до пауза до въвеждане на число и натискане на клавиша ENTER. Нека за стойност на a е въведено 5.65, следвано от ENTER. В буфера на клавиатурата се записва
cin




След изпълнението на
cin >> a;
променливата a се свързва с 5.65, а в буфера на клавиатурата остава знакът \n, т.е.
cin



ОП
a
5.65
Въвеждането на стойността на променливата b се осъществява с оператора за вход
cin >> b;
Изпълнението му води до пауза до въвеждане на число и натискане на клавиша ENTER. Нека е въведено 8.3, следвано от ENTER. В буфера на клавиатурата имаме:
cin



Изпълнението на оператора
cin >> b;
прескача знака \n, свързва 8.3 с променливата b, а в буфера на клавиатурата отново остава знакът \n, т.е.
cin



ОП
a b
5.65 8.3
Чрез оператора за вход могат да се въвеждат стойности на повече от една променлива. Фиг. 6 съдържа по-пълно негово описание.
Входът от клавиатурата е буфериран. Това означава, че всяка редица от натиснати клавиши се разглежда като пакет, който се обработва чак след като се натисне клавишът ENTER.


Оператор за вход >>
Синтаксис
cin >> <променлива>;
където
- cin е обект (променлива) от клас (тип) istream, свързан с клавиатурата,
- <променлива> е идентификатор, дефиниран, като променлива от “допустим тип”, преди оператора за въвеждане. (Типовете int, long, double са допустими).
Семантика
Извлича (въвежда) от cin (клавиатурата) поредната дума и я прехвърля в аргумента-приемник <променлива>. Конструкцията
cin >> <променлива>
е израз от тип istream със стойност левия му аргумент, т.е. резултатът от изпълнението на оператора >> е cin. Това позволява няколко думи да бъдат извличани чрез верига от оператори >>.
Следователно, допустим е следният по-общ синтаксис на >>:
cin >> <променлива> { >> <променлива>};
Операторът >> се изпълнява отляво надясно. Такива оператори се наричат ляво асоциативни. Така операторът
cin >> променлива1 >> променлива2 >> … >> променливаn;
е еквивалентен на редицата от оператори:
cin >> променлива1;
cin >> променлива2;
…
cin >> променливаn;
Освен това, ако операцията въвеждане е завършила успешно, състоянието на cin е true, в противен случай състоянието на cin е false.


Фиг. 6.

В случая от Фиг. 6, настъпва пауза. Компилаторът очаква да бъдат въведени n стойности - за променлива1, променлива2,, …, променливаn, съответно и бъде натиснат клавишът ENTER. Тези стойности трябва да бъдат въведени по подходящ начин (на един ред, на отделни редове или по няколко данни на последователни редове, слепени или разделени с интервали, табулации или знака за нов ред), като стойностi трябва да бъде от тип, съвместим с типа на променливаi (i = 1, 2, …, n).
Пример: Да разгледаме програмния фрагмент:
double a, b, c;
cin >> a >> b >> c;
Операторът за вход изисква да бъдат въведени три реални числа за a, b и c съответно. Ако се въведат
1.1 2.2 3.3 ENTER
променливата a ще се свърже с 1.1, b – с 2.2 и c – със 3.3. Същият резултат ще се получи, ако се въведе
1.1 2.2 ENTER
3.3 ENTER
или
1.1 ENTER
2.2 3.3 ENTER
или
1.1 ENTER
2.2 ENTER
3.7 ENTER
или даже ако се въведе
1.1 2.2 3.3 4.4 ENTER
В последния случай, стойността 4.4 ще остане необработена в буфера на клавиатурата и ще обслужи следващо четене, ако има. Този начин на действие съвсем не е приемлив. Още по-лошо ще стане когато се въведат данни от неподходящ тип.
Пример: Да разгледаме фрагмента:
int a;
cin >> a;
Той дефинира целочислена променлива a (a е променлива от тип int), след което настъпва пауза в очакване да бъде въведено цяло число. Нека сме въвели 1.25, следвано от ENTER. Състоянието на буфера на клавиатурата е:
cin




Операторът
cin >> a;
свързва a с 1, но не прескача останалата информация от буфера и тя ще обслужи следващо четене, което води до непредсказуем резултат. Още по-неприятна е ситуацията, когато вместо цяло число за стойност на a се въведе някакъв низ, например one, следван от ENTER. В този случай, изпълнението на
cin >> a;
ще доведе до
cin




и
ОП
a
-
т.е. стойността на променливата a не се променя (остава неопределена), а буферът на клавиатурата изпада в състояние fail. За съжаление системата не извежда съобщение за грешка, което да уведоми за възникналия проблем.
Засега препоръчваме въвеждането на коректни входни данни. Преудоляването на недостатъците, илюстрирани по-горе, ще разгледаме в следващите части на книгата.

Вече използвахме оператора за изход. Фиг. 7 описва неговите синтаксис и семантика.