Ò Каждая подпрограмма имеет структуру, подобную функции main();
Ò Каждая программа содержит одну или несколько функций;
Ò Каждая функция содержит 4 основных элемента:
1. тип возвращаемого значения; Int
2. имя функции; main()
3. список параметров, {return 0;} -
заключённый в круглые скобки
4. тело функции
- эта строка значит "вернуть операционной системе в качестве сигнала об успешном завершении программы значение 0".
#include <iostream>; //директива процессора, предназначена для включения в исходный текст содержимое заголовочного файла, имя которого< iostream>, содержащий описания функций стандартной библиотеки ввода/вывода для работы с клавиатурой и экраном.
using namespace stg; //директива означ.что все определённые ниже имена будут отн-ся к пространству имён std
Int main() //имя функции,кот.не содержит параметров и должна возвращать значение типа Int
{Int a,b; //объявление двух переменных типа Int - целый тип
cout <<”введите два целых числа”<<endl; //оператор вывода данных на экран ,
<< - операция помещения данных в выходной поток;
endl - манипулятор, переводит сообщение на новую сточку.
cin >>a >>b; //оператор ввода данных с клавиатуры,
>> - операция для извлечения данных из выходного потока, читает значения из cin и сохр. их в переменных.
cout >>”их сумма равна”<<a+b; //оператор вывода
return 0;} //оператор вывода
Ò Целые типы данных – short, int, long и спецификаторы (signed,unsigned);
Ò Вещественные типы – float, double, long double;
Ò Cсимвольные типы – char, wchar_t;
Ò Логический тип – bool, принимающий значения (true-истина, false-ложь);
Константы (const)
a=b+2,5 //неименованная константа;
‘1L’ - целочисленный литерал (тип long);
“8” – целочисл.литерал (тип Int);
‘f’, – символьный литерал, ‘\n’-конец строки
Формат описания именованной константы:
[<класс памяти>]const <тип> <имя именован-ой константы>=<выражение>;
const int l= - 124;
const floak k1=2,345, k=1/k1
Класс памяти- это спецификатор, определяющий время жизни и область видимости данного объекта.
Выражение, определяет значение именованной константы, т.е инициализирует её.
Формат описания переменных:
[<класс памяти>]<тип><имя>[=<выражение> | (<выражение>)];
Пример:
int I,j;
double x;
Значение переменных должно быть определено с помощью:
1. оператора присваивания: int a; //описание переменной
int= a; //опред.значения.переменной
2. оператора ввода: int a; //описание переменной
cin>>a; //опред.знач.переменной
3. инициализация – опред.значения переменной на этом этапе описания.
int i=100 //инициализация копией
int i (100); // прямая инициализация
Сущ.три аспекта оформления значения с плавающей запятой которыми можно управлять:
- точность( кол-во отображаемых цифр), изменяется с помощью манипулятора setprecision;
- форма записи (десятичная или экспонец-ая);
- указание десятичной точки для значения с пл.запятой, являющихся целыми числами .
- #include <iostream> Результат работы программы:
- #include <iomanip> 1.23e+004
- using namespace std; 12345.7
- int main() 12345.6789
- { double i=12345,6789;
- cout << setprecision(3)<<i<<endl;
- cout << setprecision(6)<<i<<endl;
- cout << setprecision(9)<<i<<endl;
- refurn 0;}
- (для использования манипуляторов endl с аргументами требуется подключить заголовочный файл iomanip)
Ò Используются манипуляторы:
1. lief – выравнивает вывод по левому краю;
2. right – выравнивает вывод по правому краю;
3. internal – контролирует размещение отрицательного значения: выравнивает знак по левому краю, а значение по правому, заполняя пространство между ними пробелами;
4. setprecision(int w) – устанавливает max кол-во цифр в дробной части для вещественных чисел;
5. setw(int w) – устанавливает max ширину поля вывода;
Пример: Получим:
#include <iostream> 1. Ivanov;
#include <iomanip> 2.Ivanov;
using nanespace std; 3. Ivanov;
int main()
{ cout <<“1” <<setw(10) <<“Ivanov” <<endl;
cout <<“2” <<setw(10) <<lief<<“Ivanov” <<endl;
cout <<“3” <<setw(10) <<right<<“Ivanov” <<endl;
return 0;}
Ò С помощью данных манипуляторов запишите программу, где выравнивание отриц-го числа -23,4567 будет только по правому краю.
Должно получиться: 1. -23,4567
2. -23,5
3. - 23,5
Ò Операции увеличения (декремента) и уменьшения (инкремента)
на 1(++ и --); записываются в двух формах:
Префиксия – операция записывается перед операндом и увеличивает свой операнд на 1 и возвращает изменённоё значений как результат
Постфиксия – операция записывается после операндом, уменьшает свой операнд на 1 и возвр.изменённое знач.как результат.
Пример:
#include <iosteram>
int main()
using nanespace std;
{ int x=3, y=4;
cout <<++x<<“\t”<<--y<<endl;
cout <<x++<<“\t”<<y--<<endl;
cout <<x<<“\t”<<y<<endl;
return 0;}
Операции отрицания (-,!)
Ò (-) - унарный минус – изменяет знак операнда целого или вещественного типа на противоположный;
Ò (!) – логическое отрицание, даёт в результате значение 0(ложь), если операнд отличен от 0(истина),если равен операнд 0 (ложь);
Ò тип опeранда может быть любой.
Пример:
#include <iosteram>
int main()
using nanespace std;
{ int x=3, y=0;
bool f=false, v=true;
cout <<-x<<“\t”<<!y<<endl;
cout <<-y<<“\t”<<!y<<endl;
cout <<v<<“\t”<<!v<<endl;
return 0;}
Ò Арифметические операции: умножение.(*), деление.(/), остаток от деления.(%); слож.(+), вычит.(-)
Рассмотрим операции деления и остаток от деления:
#include <iosteram>
using nanespace std;
int main()
{ cout <<100/24<<“\t”<<100/24<<endl;
cout <<100/21<<“\t”<<100,0/24<<endl;
cout <<21%3<<“\t”<<21%6<<“-21%8”<<endl;
return 0;}
- Операции отрицания (-,!) унарный минус – изменяет знак операнда целого или вещест-го типа на противоположный.
- Операции отношения: (<, <=, >, >=, == !=), меньше, меньше или равно, больше, больше или равно, равно, не равно, не равно соответственно).
Результатом операций являются значения true, false.
Логические операции (&& и ||)
И (&&) - возвращает значение истина тогда и только тогда, когда оба операнда принимают значение истина, в противном случае операция возращ.знач.ложь.
ИЛИ || - возвращает знач.истина тогда и.т.тогда, когда хотя бы один операнд принимает значение истина, в противном случае –ложь
- логические операции выполняются слева направо;
- приоритет операции && выше ||.
Пример:
#include <iosteram>
using namespace std;
int main()
{ cout <<‘x\t y\t &&\t||’endl;
cout <<“0\t 1\t”<<(0 && 1)<<‘\t’<<(0||1)endl;
cout <<‘0\t 1\t’<<(0 && 1)<<\t’<< (0||1)endl;
cout <<‘1\t 0\t’<<(1 && 0)<<‘\t’<<(1||0)endl;
cout <<‘1\t 1\t’<<(1 && 1)<<‘\t’<<(1||1)endl;
return 0;}
Ò формат операция простого присваивания (=):
Ò опреанд_1 = операнд_2
пример: a=b=c=100, это выражение выполняется справа налево, результатом выполнения с=100, является число 100, которое затем присвоиться переменной b, потом а.
Ò Сложные операции присваивания:
Ò (*=) – умножение с присв-ем,
Ò ( /=) - деление с присв-ем
Ò (%= )- остаток от деления с присв-ем,
Ò (+=) –сложение с присв.,
Ò (-=) - вычит.с присв.
Ò пример: к операнду _1 прибавляется операнд_2 и результат записывается в операнд_2
Ò т.е. с = с + а, тогда компактная запись с += а
Ò Условная операция (? : )
Ò Формат условной операции: операнд_1 ? операнд_2 ? : операнд_3
Ò Операнд_1 это логическое или арифметич-ое выражение;
Ò Оценивается с точки зрения эквивалентности константам true и false;
Ò Если результат вычисления операнда_1 равен true,то результат условной операции будет значение операнда_2, иначе операнда_3;
Ò Тип может различаться;
Ò Условная операция является сокращ. формой услов-го оператора if;
Пример: Результат:
#include <iosteram> для х=11 и y=9
int main() 11
using nanespace std; 11
{ int x, y,max;
cin >>x>>y;
(x>y)? cout <<x: cout<<y<<endl; //1 нахождение наибольшего зна-
max=(x>y)? x:y; //2 чения для двух целых чисел;
cout<<max<<endl;
return 0;}
Ò
Ò Примеры:
Ò (a+0,12)/6; x && y || !z;
Ò (t*sin(x)-1,05e4)/((2*k+2)*(2*k+3))4;
Ò операции выполняются в соответствии с приоритетом;
Ò если в одном выражении имеются неск.операций одинаково приоритета, то унарные операции выполняются- справа
Ò налево, остальные –слева направо
Ò Т.е : a= b+c значит a=(b=c),
Ò а + b+c значит (a +b) +c
Ò в выражения могут входить операнды различных типов;
Ò при одинаковом типе операндов, результат будет им.тот же тип;
Ò если разного типа операнды, то операнд с более «низким» типом будет преобразован к более «высокому» типу для сохранения значимости и точности:
Неявное преобразование:
include <iosteram>
using nanespace std;
int main()
{ int a=100, b; float c=4,5, d;