Презентация на тему Простейший ввод-вывод. Управляющие операторы

консольного ввода-вывода (класс Console) и управляющие операторы языка (ветвления,

циклы, передача управления).

Class1
{ static void Main()

{
int i = 3;
double y = 4.12;
decimal d = 600m;
string s = "Вася";



}
}
}

Вывод на консоль

Результат работы программы:
3 y = 4,12
d = 600 s = Вася

Console.Write( i );
Console.WriteLine( " y = " + y);
Console.WriteLine("d = " + d + " s = " + s );

Console.Write( i );
Console.Write( " y = {0} \nd = {1}", y, d );
Console.WriteLine( " s = " + s );

Console.Write( i );
Console.Write( " y = {0:F2} \nd = {1:D3}", y, d );
Console.WriteLine( " s = " + s );

Console.Write( " y = {0,5:0.# ' руб. '} \n", y );

Class1
{ static void Main()

{
string s = Console.ReadLine(); // ввод строки

char c = (char)Console.Read(); // ввод символа
Console.ReadLine();

string buf; // буфер для ввода чисел
buf = Console.ReadLine();
int i = Convert.ToInt32( buf ); // преобразование в целое

buf = Console.ReadLine();
double x = Convert.ToDouble( buf ); // преобразование в вещ.

buf = Console.ReadLine();
double y = double.Parse( buf ); // преобразование в вещ.
}
}
}

Ввод с консоли

Class1
{ static void Main()

{
Console.WriteLine( "Введите температуру по Фаренгейту" );
double fahr = Convert.ToDouble(Console.ReadLine() );

double cels =5.0 / 9 * (fahr - 32);

Console.WriteLine( "По Фаренгейту: {0} в градусах Цельсия: {1}",
fahr, cels );
}
}
}

Пример: перевод температуры из F в С

следование
ветвление
цикл
передача управления

последовательность операторов, заключенная в операторные скобки:
begin end
{

}
Блок воспринимается компилятором как один оператор и может использоваться всюду, где синтаксис требует одного оператора, а алгоритм — нескольких.
Блок может содержать один оператор или быть пустым.

с запятой, рассматривается как оператор, выполнение которого заключается в

вычислении выражения.

i++; // выполняется операция инкремента
a *= b + c; // выполняется умножение с присваиванием
fun( i, k ); // выполняется вызов функции

когда по синтаксису оператор требуется, а по смыслу —

нет:
while ( true );

Это цикл, состоящий из пустого оператора (бесконечный)

;;;
Три пустых оператора

< 0 ) b = 1;
if ( a

b && (a > d || a == 0)) ++b; else { b *= a; a = 0; } if ( a < b ) if ( a < c ) m = a; else m = c; else if ( b < c ) m = b; else m = c;

if ( выражение ) оператор_1; [else оператор_2;]

Class1
{ static void Main()

{
Console.WriteLine( "Введите координату x" );
double x = Convert.ToDouble(Console.ReadLine() );

Console.WriteLine( "Введите координату у" );
double y = double.Parse(Console.ReadLine() );

if ( x * x + y * y <= 1 ||
x <= 0 && y <= 0 && y >= - x – 2 )
Console.WriteLine( " Точка попадает в область " );
else
Console.WriteLine( " Точка не попадает в область " );
}}}

-2 )

y = 0;
if ( x >= -2 && x < -1 ) y = -x - 2;
if ( x >= -1 && x < 1 ) y = x;
if ( x >= 1 && x < 2 ) y = -x + 2;
if ( x >= 2 ) y = 0;

if ( x <= -2 ) y = 0;
else if ( x < -1 ) y = -x - 2;
else if ( x < 1 ) y = x;
else if ( x < 2 ) y = -x + 2;
else y = 0;

y = 0;
if ( x > -2 ) y = -x - 2;
if ( x > -1 ) y = x;
if ( x > 1 ) y = -x + 2;
if ( x > 2 ) y = 0;

погрешности представления вещественных значений в памяти следует ее избегать,

вместо этого лучше сравнивать модуль разности с некоторым малым числом.
float a, b; …
if ( a == b ) … // не рекомендуется!
if ( Math.Abs(a - b) < 1e-6 ) … // надежно!
Значение величины, с которой сравнивается модуль разности, следует выбирать в зависимости от решаемой задачи и точности участвующих в выражении переменных.
Снизу эта величина ограничена определенной в классах Single и Double константой Epsilon. Это минимально возможное значение переменной такое, что
1.0 + Epsilon != 1.0

){
case константное_выражение_1: [ список_операторов_1 ]
case константное_выражение_2: [ список_операторов_2 ]

case

константное_выражение_n: [ список_операторов_n ]
[ default: операторы ]
}

using System; namespace ConsoleApplication1
{ class Class1 {

static void Main() {
string buf; double a, b, res;
Console.WriteLine( "Введите 1й операнд:" );
buf = Console.ReadLine(); a = double.Parse( buf);
Console.WriteLine( "Введите знак" );
char op = (char)Console.Read(); Console.ReadLine();
Console.WriteLine( "Введите 2й операнд:" );
buf = Console.ReadLine(); b = double.Parse( buf);
bool ok = true;
switch (op)
{
case '+' : res = a + b; break;
case '-' : res = a - b; break;
case '*' : res = a * b; break;
case '/' : res = a / b; break;
default : res = double.NaN; ok = false; break;
}
if (ok) Console.WriteLine( "Результат: " + res );
else Console.WriteLine( "Недопустимая операция" );
}}}

выражение ) оператор
using System;
namespace ConsoleApplication1
{ class Class1

{ static void Main()
{
double Xn = -2, Xk = 12, dX = 2, t = 2, y;
Console.WriteLine( "| x | y |" );
double x = Xn;
while ( x <= Xk )
{
y = t * x;
Console.WriteLine( "| {0,9} | {1,9} |", x, y );
x += dX;
}
}
}
}

y = t⋅x

while выражение;

using System;
namespace ConsoleApplication1
{ class Class1
{

static void Main()
{
char answer;
do
{
Console.WriteLine( "Купи слоника, а?" );
answer = (char) Console.Read();
Console.ReadLine();
} while ( answer != 'y' );
}
}
}

инициализация; выражение; модификации ) оператор;

int s = 0;
for (

int i = 1; i <= 100; i++ ) s += i;

Class1
{ static void Main()

{
double Xn = -2, Xk = 12, dX = 2, t = 2, y;
Console.WriteLine( "| x | y |";
for ( double x = Xn; x <= Xk; x += dX )
{
y = t * x;
Console.WriteLine( "| {0,9} | {1,9} |", x, y );
}
}
}
}

Пример цикла с параметром

о том, что если в теле циклов while и

for требуется выполнить более одного оператора, нужно заключать их в блок;
убедиться, что всем переменным, встречающимся в правой части операторов присваивания в теле цикла, до этого присвоены значения, а также возможно ли выполнение других операторов;
проверить, изменяется ли в теле цикла хотя бы одна переменная, входящая в условие продолжения цикла;
предусматривать аварийный выход из итеративного цикла по достижению некоторого предельно допустимого количества итераций.

выполнение цикла, внутри которого записан;
оператор continue — выполняет переход

к следующей итерации цикла;
оператор return — выполняет выход из функции, внутри которой он записан;
оператор throw — генерирует исключительную ситуацию;
оператор goto — выполняет безусловную передачу управления

вычисления значения функции sin с помощью степенного ряда с

точностью по формуле:

Class1
{ static void Main()

{ double e = 1e-6; const int iterLimit = 500;
Console.WriteLine( "Введите аргумент:" );
double x = Convert.ToDouble(Console.ReadLine());

Пример: вычисление суммы ряда

bool error = false; // признак ошибки
double c = x, y = c; // член ряда и сумма ряда
for ( int n = 1; Math.Abs(c) > e; n++ )
{ c *= - x * x / ((2 * n ) * ( 2 * n + 1 ));
y += c;
if ( n > iterLimit ) { error = true; break; }
}
if ( error ) Console.WriteLine( "Ряд расходится" );
else Console.WriteLine( "Сумма ряда - " + y );
}}} end.

и передает управление в точку ее вызова:
return [ выражение

];

Оператор goto

goto метка;
В теле той же функции должна присутствовать ровно одна конструкция вида:
метка: оператор;

goto case константное_выражение;
goto default;

возникновение непредвиденного или аварийного события, которое может порождаться некорректным

использованием аппаратуры.
Например, это деление на ноль или обращение по несуществующему адресу памяти.

Исключения позволяют логически разделить вычислительный процесс на две части — обнаружение аварийной ситуации и ее обработка.

программы;
возвратить значение, означающее «ошибка»;
вывести сообщение об ошибке и вернуть

вызывающей программе некоторое приемлемое значение, которое позволит ей продолжать работу;
выбросить исключение


Исключения генерирует либо система выполнения, либо программист с помощью оператора throw.

и обработки исключений.
Оператор содержит три части:
контролируемый блок — составной оператор,

предваряемый ключевым словом try. В контролируемый блок включаются потенциально опасные операторы программы. Все функции, прямо или косвенно вызываемые из блока, также считаются ему принадлежащими;
один или несколько обработчиков исключений — блоков catch, в которых описывается, как обрабатываются ошибки различных типов;
блок завершения finally, выполняемый независимо от того, возникла ли ошибка в контролируемом блоке.

Синтаксис оператора try:
try блок [ catch-блоки ] [ finally-блок ]

с появления ошибки. Функция или операция, в которой возникла

ошибка, генерируют исключение;
Выполнение текущего блока прекращается, отыскивается соответствующий обработчик исключения, и ему передается управление.
В любом случае (была ошибка или нет) выполняется блок finally, если он присутствует.
Если обработчик не найден, вызывается стандартный обработчик исключения.

// Контролируемый блок
}
catch ( OverflowException e )

{

// Обработка переполнения
}
catch ( DivideByZeroException ) {

// Обработка деления на 0
}
catch {
// Обработка всех остальных исключений
}

void Main()
{

try
{
Console.WriteLine( "Введите напряжение:" );
double u = double.Parse( Console.ReadLine() );
Console.WriteLine( "Введите сопротивление:" );
double r = double.Parse(Console.ReadLine() );
double i = u / r;
Console.WriteLine( "Сила тока - " + i );
}
catch ( FormatException )
{
Console.WriteLine( "Неверный формат ввода!" );
}
catch // общий случай
{
Console.WriteLine( "Неопознанное исключение" );
}
}

];
Пример:

throw new DivideByZeroException();
Параметр должен быть объектом, порожденным от стандартного

класса System.Exception. Этот объект используется для передачи информации об исключении его обработчику.