Введение в C# реферат по программированию и компьютерам скачать бесплатно поля методы классы объекты массив элементы строки задания переменные Case доступа типы использование символы оператор пример, Сочинения из Программирование. Moscow State University
refbank18437
refbank1843711 апреля 2017 г.

Введение в C# реферат по программированию и компьютерам скачать бесплатно поля методы классы объекты массив элементы строки задания переменные Case доступа типы использование символы оператор пример, Сочинения из Программирование. Moscow State University

DOC (169 KB)
19 страница
8Количество скачиваний
522Количество просмотров
Описание
Введение в C# реферат по программированию и компьютерам скачать бесплатно поля методы классы объекты массив элементы строки задания переменные Case доступа типы использование символы оператор пример
20 баллов
Количество баллов, необходимое для скачивания
этого документа
Скачать документ
Предварительный просмотр3 страница / 19

Это только предварительный просмотр

3 страница на 19 страницах

Скачать документ

Это только предварительный просмотр

3 страница на 19 страницах

Скачать документ

Это только предварительный просмотр

3 страница на 19 страницах

Скачать документ

Это только предварительный просмотр

3 страница на 19 страницах

Скачать документ

Министерство Образования РФ КУБАНСКИЙ ГОСУДАРСТВЕННЫЙ ТЕХНОЛОГИЧЕСКИЙ УНИВЕРСИТЕТ

Реферат на тему: «Языки программирования. Введение в C#»

Выполнил: Студент гр. 04-К-ЗИ1

Степанов Д.В.

Краснодар, 2007 Содержание:

1)Типы и операторы

2)Инструкции управления 3)Массивы и строки 4)Введение в классы: поля, методы и объекты 5)Наследование 6)Исключительные ситуации 7)Список используемой литературы

1) Типы и операторы. С# содержит две категории встроенных типов данных: типы значений и ссылочные типы. Термин "тип значения" применяется к переменным, которые непосредственно содержат значения. (Для сравнения: переменные ссылочных типов содержат ссылки на реальные значения). Таким образом, типы значений в С# во многом подобны типам данных, определенных в других языках программирования (например, C++). Типы значений также называют простыми типами. В С# строго определяется диапазон и поведение каждого типа значения. Исходя из требований переносимости, С# на этот счет не допускает никаких компромиссов. Например, тип int должен быть одинаковым во всех средах выполнения.

Ядро языка С# составляют 13 типов. Это - встроенные типы, которые определяются ключевыми словами С# и доступны для использования в любой C# программе.

ключевое слово тип bool Логический, представляет значения истина/ложь. byte 8-разрядный целочисленный без знака. char Символьный. decimal Числовой тип для финансовых вычислений. double С плавающей точкой двойной точности. float С плавающей точкой. int Целочисленный. long Тип для представления длинного целого числа. sbyte 8-разрядный целочисленный со знаком. short Тип для представления короткого целого числа. uint Целочисленный без знака. ulong Тип для представления длинного целого числа без знака. ushort Тип для представления короткого целого числа без знака.

В С# определено девять целочисленных типов: char, byte, sbyte, short, ushort, int, uint, long и ulong. Однако тип char в основном используется для представления символов. Типы с плавающей точкой могут представлять числа с дробными компонентами. Таких типов только два: float и double. Тип bool представляет значения истина/ложь, которые в С# определяются зарезервированными словами true и false. Таким образом, переменная или выражение типа bool будет иметь одно из этих двух значений. В С# не определено ни одно преобразование значения типа bool в целочисленное значение. Например, число 1 не преобразуется в значение true, а число 0 - в значение false.

Для объявления переменной необходимо использовать инструкцию следующего формата:

тип имя_переменной;

Здесь с помощью элемента тип задается тип объявляемой переменной, а с помощью элемента имя_переменной - ее имя. Можно объявить переменную любого допустимого типа. Все переменные в С# должны быть объявлены до их использования. Это - требование компилятора, поскольку, прежде чем скомпилировать надлежащим образом инструкцию, в которой используется переменная, он должен "знать" тип содержащейся в ней информации.

Переменная до использования должна получить значение. Это можно сделать с помощью инструкции присваивания. Можно также присвоить переменной начальное значение одновременно с ее объявлением. Для этого достаточно после имени переменной поставить знак равенства и указать присваиваемое значение. Общий формат инициализации переменной имеет такой вид:

тип имя_переменной = значение;

В С# предусмотрен широкий набор операторов, которые дают в руки программисту мощные рычаги управления при создании разнообразнейших выражений и их вычислении. Имеется четыре общих класса операторов: арифметические (“+”, “-“, “*”,

“/”, “%”,”++”.”—“), поразрядные (“&”, “|”, “^”, “>>”, “<<”, “~”), логические (“&”, “|”, “^”, “&&”, “||”, “!”) и операторы отношений (“==”. “!=”, “>”, “<”, “>=”, “<=”).

Задание: написать программу, производящую простые арифметические операции над числами (сложение, вычитание, умножение и деление).

Пример:

using System;

namespace ConsoleApplication { class OurClass { static void Main(string[] args) {

float num1, num2; Console.Write("Введите первое число:"); num1 = float.Parse(Console.ReadLine());

Console.Write("Введите второе число:"); num2 = float.Parse(Console.ReadLine());

float summarize = num1 + num2; float multiply = num1 * num2; float sub = num1 - num2; float divide = num1 / num2;

Console.WriteLine( "\n" + num1 + " + " + num2 + " = " + summarize +

"\n" + num1 + " * " + num2 + " = " + multiply + "\n" + num1 + " - " + num2 + " = " + sub + "\n" + num1 + " / " + num2 + " = " + divide); Console.Write("\nДля выхода из программы нажмите [Enter]:");

string anykey = Console.ReadLine(); } } }

2) Инструкции управления. Существует три категории управляющих инструкций: инструкции выбора (if, switch), итерационные инструкции (состоящие из for-, while-, dowhile- и foreach-циклов) и инструкции перехода (break, continue, goto, return и throw). Рассмотрим подробно инструкции управления if, switch, for и while.

Формат записи if-инструкции принимает такой вид: if (условие) { последовательность инструкций } else {

последовательность инструкций }

Если элемент условие, который представляет собой условное выражение, при вычислении даст значение истина, будет выполнена if-инструкция; в противном случае - else-инструкция (если таковая существует). Обе инструкции никогда не выполняются. Условное выражение, управляющее выполнением if-инструкции, должно иметь тип bool. Вложенные if-инструкции образуются в том случае, если в качестве элемента инструкция используется другая if-инструкция. Вложенные if-инструкции очень популярны в программировании. Главное здесь - помнить, что else-инструкция всегда относится к ближайшей if-инструкции, которая находится внутри того же программного блока, но еще не связана ни с какой другой else-инструкцией.

Инструкция switch обеспечивает многонаправленное ветвление. Она позволяет делать выбор одной из множества альтернатив. Хотя многонаправленное тестирование можно реализовать с помощью последовательности вложенных if-инструкций, для многих ситуаций инструкция switch оказывается более эффективным решением. Общий формат записи инструкции switch такой:

switch(выражение) { case константа1: последовательность инструкций break; case константа2: последовательность инструкций break; case константаЗ: последовательность инструкций break; default: последовательность инструкций break; }

Элемент выражение инструкции switch должен иметь целочисленный тип (например, char, byte, short или int) или тип string. Выражения, имеющие тип с плавающей точкой, не разрешены. Очень часто в качестве управляющего switch-выражения используется просто переменная; case-константы должны быть литералами, тип которых совместим с типом заданного выражения. При этом никакие две case-константы в одной switch- инструкции не могут иметь идентичных значений. Последовательность инструкций default-ветви выполняется в том случае, если ни одна из заданных case-констант не совпадет с результатом вычисления switch-выражения. Ветвь default необязательна. Если она отсутствует, то при несовпадении результата выражения ни с одной из case- констант никакое действие выполнено не будет. Если такое совпадение все-таки обнаружится, будут выполнены инструкции, соответствующие данной case-ветви до тех пор, пока не встретится инструкция break. Инструкция switch может быть использована как часть case-последовательности внешней инструкции switch. В этом случае она называется вложенной инструкцией switch. Необходимо отметить, что case-константы внутренних и внешних инструкций switch могут иметь одинаковые значения, при этом никаких конфликтов не возникнет.

Общий формат записи цикла for для повторного выполнения одной инструкции имеет следующий вид:

for (инициализация; условие; итерация) { последовательность инструкций }

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

Оставив пустым условное выражение цикла for, можно создать бесконечный цикл (цикл, который никогда не заканчивается). Этот цикл будет работать без конца:

for (;;) { // cпециально созданный бесконечный цикл. }

Несмотря на существование некоторых задач программирования (например, командных процессоров операционных систем), которые требуют наличия бесконечного цикла, большинство "бесконечных циклов" - это просто циклы со специальными требованиями к завершению.

Общая форма цикла while имеет такой вид: while (условие) { последовательность инструкций }

Здесь под элементом последовательностьинструкций понимается либо одиночная инструкция, либо блок инструкций. Работой цикла управляет элемент условие, который представляет собой любое допустимое выражение типа bool. Элемент инструкция выполняется дотех пор, пока условное выражение возвращает значение истина. Как только это условие становится ложным, управление передается инструкции, которая следует за этим циклом.

Задание: написать программу, решающую уравнение f(x) = 1/(x-3) для целых чисел x, находящихся на промежутке [0;10].

Пример:

using System;

namespace ConsoleApplication { class OurClass { static void Main(string[] args) {

float result; Console.WriteLine("f(x)=1/(x-3)"+

"\nx - целые числа на промежутке [0;10]\n"); for(float i = 0; i < 10; i++) { if (!(i == 3)) { result = 1/(i-3);

Console.WriteLine("i = " + i + "; f(x) = " + result); } else { Console.WriteLine("При x = 3 уравнение не имеет "+

"решений, так как на нуль делить нельзя!"); } } Console.Write("\nДля выхода из программы нажмите [Enter]:"); string anykey = Console.ReadLine();

} } }

3) Массивы и строки. Массив - это коллекция переменных одинакового типа, обращение к которым происходит с использованием общего для всех имени. В С# массивы могут быть одномерными или многомерными, хотя в основном используются одномерные массивы. Одномерный массив - это список связанных переменных. Для объявления одномерного массива используется следующая форма записи.

тип[] имя_массива = new тип [размер];

Формат инициализации одномерного массива имеет следующий вид: тип[]имя_массива = [val1, val2,…, valN];

Здесь начальные значения, присваиваемые элементам массива, задаются с помощью последовательности val1-vaIN. Для получения доступа к элементу одномерного массива требуется указать индекс требуемого элемента:

имя_массива[индекс] = val;

Несмотря на то, что в программировании чаще всего используются одномерные массивы, их многомерные "собратья" - также не редкость. Многомернымназывается такой массив, который характеризуется двумя или более измерениями, а доступ к отдельному элементу осуществляется посредством двух или более индексов. Простейший многомерный массив - двумерный. В двумерном массиве позиция любого элемента определяется двумя индексами. Если представить двумерный массив в виде таблицы данных, то один индекс означает строку, а второй - столбец. Чтобы объявить двумерный массив целочисленных значений размером AxB, достаточно записать следующее:

int[,]имя_массива = new int[A,B];

Чтобы получить доступ к элементу двумерного массива, необходимо указать оба индекса, разделив их запятой. Например, чтобы присвоить число Z элементу двумерного массива, позиция которого определяется координатами x и y, можно использовать следующую инструкцию:

имя_массива[x,y] = Z;

Многомерный массив можно инициализировать, заключив список инициализаторов каждой размерности в собственный набор фигурных скобок. Например, вот каков формат инициализации многомерного массива:

тип[,] имя_массива = { {val, val, val, …, val} {val, val val, …, val} … {val, val, val, …, val} };

Здесь элемент val – значение инициализации. Каждый внутренний блок означает строку. В каждой строке первое значение будет сохранено в первой позиции массива, второе значение - во второй и т.д.

С точки зрения ежедневного программирования одним из самых важных типов данных С# является тип string. Он предназначен для определения и поддержки символьных строк. Самый простой способ создать объект типа string - использовать строковый литерал:

string str = "С#-строки - это мощная сила.";

Последовательность символов, составляющих строку, изменить нельзя. Хотя это кажется серьезным недостатком, на самом деле это не так. Это ограничение позволяет С# эффективно использовать строки. Если вам понадобится строка, которая должна представлять собой "вариацию на тему" уже существующей строки, создайте новую строку, которая содержит желаемые изменения. Поскольку неиспользуемые строковые объекты автоматически утилизируются системой сбора мусора, даже не нужно беспокоиться о "брошенных" строках.

Задание: написать программу для работы с матрицей: а) поиск максимального элемента в каждой строке; б) суммирование элементов каждой строки.

Пример:

using System;

namespace ConsoleApplication { class OurClass { static void Main(string[] args) {

int size; float tmp; Console.Write("Введите размерность матрицы:"); size = Int32.Parse(Console.ReadLine()); float[,] matrix = new float[size,size];

Console.WriteLine("Введите элементы матрицы:"); for(int i = 0; i < size; i++) {

for(int j = 0; j < size; j++) { Console.Write("A[" + i + ";" + j + "] = ");

matrix[i,j] = float.Parse(Console.ReadLine()); } } Console.WriteLine("");

for(int i = 0; i < size; i++) { for(int j = 0; j < size; j++) { Console.Write(matrix[i,j]+" "); }

Console.WriteLine(""); }

Console.Write("\nМаксимальный элемент:\n");

for(int i = 0; i < size; i++) { tmp = matrix[i,0];

for(int j = 0; j < (size-1); j++) { if ((matrix[i,j+1] > tmp) && (matrix[i,j+1] > matrix[i,j])) { tmp = matrix[i,j+1]; }

} Console.Write(i + " строка: " + tmp + "\n"); }

Console.WriteLine("\nСумма элементов:");

for(int i = 0; i < size; i++) { tmp = 0;

for(int j = 0; j < size; j++) { tmp += matrix[i,j]; }

Console.WriteLine(i + " строка: " + tmp); }

Console.Write("\nДля выхода из программы нажмите [Enter]:"); string anykey = Console.ReadLine();

} } }

4) Введение в классы: поля, методы и объекты. Все С#-программы оформляются в виде класса. Класс - это шаблон, который определяет форму объекта. Он задает как данные, так и код, который оперирует этими данными. С# использует спецификацию класса для создания объекта. Объекты - это экземпляры класса. Таким образом, класс - это множество намерений (планов), определяющих, как должен быть построен объект. Важно четко понимать следующее: класс - это логическая абстракция. О ее реализации нет смысла говорить до тех пор, пока не создан объект класса, и в памяти не появилось физическое его представление. Класс создается с помощью ключевого слова class. Общая форма определения класса, который содержит только переменные экземпляров и методы, имеет следующий вид:

class имя_класса { // Объявление переменных экземпляров. доступ тип переменная!; доступ тип переменная2; //… доступ тип переменнаяN; // Объявление методов. доступ тип_возврата метод1 (параметры) {

// тело метода } доступ тип_возврата метод2 (параметры) { // тело метода } }

Чтобы реально создать объект класса Cat, используйте, например, такую инструкцию: Cat Murzik = new Cat();

Это объявление выполняет две функции. Во-первых, оно объявляет переменную с именем Murzik классового типа Cat. Но эта переменная не определяет объект, а может лишь ссылаться на него. Во-вторых, рассматриваемое объявление создает реальную физическую копию объекта и присваивает переменной Murzik ссылку на этот объект. И все это - "дело рук" оператора new. Таким образом, после выполнения приведенной выше строки кода переменная Murzik будет ссылаться на объект типа Cat. Помните, что объявление class - это лишь описание типа; оно не создает реальных объектов.

При каждом создании экземпляра класса создается объект, который содержит собственную копию каждой переменной экземпляра, определенной этим классом. Таким образом, каждый объект класса Cat будет содержать собственные копии переменных экземпляра объявленных в классе. Для доступа к этим переменным используется оператор "точка" (.). Оператор "точка" связывает имя объекта с именем его члена. Общий формат этого оператора имеет такой вид:

объект.член

Переменные экземпляров (поля) и методы - две основные составляющие классов. Управление доступом к членам класса достигается за счет использования четырех спецификаторов доступа:public, private, protected и internal. public разрешает доступ к соответствующему члену класса со стороны другого кода программы, включая методы, определенные внутри других классов; private разрешает доступ к соответствующему члену класса только для методов, определенных внутри того же класса (таким образом, методы других классов не могут получить доступ к private-члену не их класса); protected применяется для создания защищенных членов класса; internal применяется в основном при использовании компоновочных файлов. При отсутствии спецификатора доступа член класса является закрытым (private) по умолчанию. Методы— это процедуры (подпрограммы), которые манипулируют данными, определенными в классе, и во многих случаях обеспечивают доступ к этим данным. Обычноразличные части программы взаимодействуют с классом посредством его методов. Формат записи метода такой:

доступ тип_возврата имя(список_параметров) { // тело метода }

В общем случае существует два варианта условий для возвращения из метода. Первый связан с обнаружением закрывающей фигурной скобки, обозначающей конец тела метода. Второй вариант состоит в выполнении инструкции return. Возможны две формы

использования инструкции return: одна предназначена для void-методов (которые не воз- вращают значений), а другая - для возврата значений. При вызове методу можно передать одно или несколько значений. Значение, передаваемое методу, называется аргументом. Переменная внутри метода, которая принимает значение аргумента, называется параметром. Параметры объявляются внутри круглых скобок, которые следуют за именем метода. Синтаксис объявления параметров аналогичен синтаксису, применяемому для переменных. Параметр находится в области видимости своего метода, и, помимо специальной задачи получения аргумента, действует подобно любой локальной переменной.

Задание: написать программу для обработки (суммирование элементов; поиск максимального и минимального элемента) одномерного массива чисел. Для этого создать дополнительный класс (Processing) и реализовать в нем соответствующие методы.

Пример:

using System;

namespace ConsoleApplication { public class Processing { private float tmp = 0;

public float summarize(float[] A, int length) { for(int i = 0; i < length; i++) {

tmp += A[i]; }

return tmp; } public float find_max(float[] A, int length) { tmp = A[0];

for(int i = 0; i < (length-1); i++) { if ((A[i+1] > tmp) && (A[i+1] > A[i])) { tmp = A[i+1]; } }

return tmp; } public float find_min(float[] A, int length) {

tmp = A[0]; for(int i = 0; i < (length-1); i++) {

if ((A[i+1] < tmp) && (A[i+1] < A[i])) { tmp = A[i+1]; } }

return tmp; } } class OurClass { static void Main(string[] args) { Processing Do = new Processing(); int size;

Console.Write("Количество элементов массива:"); size = Int32.Parse(Console.ReadLine()); float[] array = new float[size];

Console.WriteLine("Введите элементы массива:"); for(int i = 0; i < size; i++) { Console.Write("A[" + i + "] = ");

array[i] = float.Parse(Console.ReadLine()); } Console.WriteLine("");

Console.Write("{ "); for(int i = 0; i < size; i++) { Console.Write(array[i] + "; "); } Console.WriteLine(" }");

Console.WriteLine("Сумма всех элементов: " + Do.summarize(array, size)); Console.WriteLine("Максимальный элемент: " + Do.find_max(array, size));

Console.WriteLine("Минимальный элемент: " + Do.find_min(array, size));

Console.Write("\nДля выхода из программы нажмите [Enter]:"); string anykey = Console.ReadLine();

} } }

5) Наследование. Наследование - один из трех фундаментальных принципов объектно-ориентированного программирования, поскольку именно благодаря ему возможно создание иерархических классификаций. Используя наследование, можно создать общий класс, который определяет характеристики, присущие множеству связанных элементов. Этот класс затем может быть унаследован другими, узкоспециализированными классами с добавлением в каждый из них своих, уникальных особенностей. В языке С# класс, который наследуется, называется базовым. Класс, который наследует базовый класс, называется производным. Следовательно, производный класс - это специализированная версия базового класса. В производный класс, наследующий все переменные, методы, свойства, операторы и индексаторы, определенные в базовом классе, могут быть добавлены уникальные элементы. Если один класс наследует другой, то имя базового класса указывается после имени производного, причем имена классов разделяются двоеточием. В С# синтаксис наследования класса очень прост для запоминания и использования.

class имя_производного_класса : имя_базового_класса { // тело класса }

Для создаваемого производного класса можно указать только один базовый класс. В С# (в отличие от C++) не поддерживается наследование нескольких базовых классов в одном производном классе. Этот факт необходимо учитывать при переводе С++-кода на С#. Однако можно создать иерархию наследования, в которой один производный класс становится базовым для другого производного класса. И, конечно же, ни один класс не может быть базовым (ни прямо, ни косвенно) для самого себя. Основное достоинство наследования состоит в том, что, создав базовый класс, который определяет общие атрибуты для множества объектов, его можно использовать для создания любого числа более специализированных производных классов. В каждом производном классе можно затем точно "настроить" собственную классификацию. Члены класса часто объявляются закрытыми, чтобы предотвратить несанкционированное использование и внесение изменений. Наследование класса неотменяет ограничения, связанные с закрытым доступом. Таким образом, несмотря на то, что производный класс включает все члены базового класса, он не может получить доступ к закрытым членам. С# позволяет создавать защищенные члены. Защищенным является член, который открыт для своей иерархии классов, но закрыт вне этой иерархии. Защищенный член создается с помощью модификатора доступа protected. При объявлении protected-члена он, по сути, является закрытым, но с одним исключением. Это исключение вступает в силу, когда защищенный член наследуется. В этом случае защищенный член базового класса становится защищенным членом производного класса, а следовательно, и доступным для производного класса. Таким образом, используя модификатор доступа protected, можно создавать закрытые (для "внешнего мира") члены класса, но вместе с тем они будут наследоваться с возможностью доступа со стороны производных классов. Подобно модификаторам public и private модификатор protected остается со своим членом независимо от реализуемого количества уровней наследования. Следовательно, при использовании производного класса в качестве базового для создания другого производного класса любой защищенный член исходного базового класса, который наследуется первым производным классом, также наследуется в статусе защищенного и вторым производным классом.

Задание: написать программу для сортировки одномерного массива чисел и поиска/замены в нем данных. Для решения поставленной задачи создать два дополнительных класса (базовый и производный). В базовом классе (Base) реализовать методы сортировки методом пузырька и методом вставки. В производном (Inheriting) реализовать методы поиска и замены символов (символ поиска и символы для замены выбираются студентом).

Пример:

using System;

namespace ConsoleApplication { public class Base { public void sorting_bubble(float[] A, int length) { float x;

for(int i = 0; i < length; i++) { for(int j = length-1; j > i; j--) {

if (A[j-1] > A[j]) { x = A[j-1]; A[j-1] = A[j]; A[j] = x; }

} }

draw_result(A, length);

} public void sorting_insert(float[] A, int length) { for(int i = 1; i < length; i++) {

float x = A[i]; if (x < A[i-1]) { A[i] = A[i-1]; int j = i-2; while ((j >=0) && (x < A[j])) { A[j+1] = A[j--]; } A[j+1] = x; }

} draw_result(A, length); } public void draw_result(float[] drawA, int drawLength) { Console.Write("{ ");

for(int i = 0; i < drawLength; i++) { Console.Write(drawA[i] + "; "); }

Console.WriteLine(" }"); } } public class Inheriting : Base { public string search(float[] A, float digit, int length) { string tmp = "";

for(int i = 0; i < length; i++) { if (A[i] == digit) { tmp += "(" + digit + ") найдено в A[" + i + "]\n"; } }

return tmp; } public void replace(float[] A, float find, float replace, int length) { for(int i = 0; i < length; i++) {

if (A[i] == find) { A[i] = replace; } }

draw_result(A, length); } } class OurClass { static void Main(string[] args) { Inheriting Do = new Inheriting(); int size;

string what_to_do; float for_find, for_replace; Console.Write("Количество элементов массива:"); size = Int32.Parse(Console.ReadLine());

float[] array = new float[size]; Console.WriteLine("Введите элементы массива:"); for(int i = 0; i < size; i++) { Console.Write("A[" + i + "] = "); array[i] = float.Parse(Console.ReadLine()); } Console.WriteLine("");

Console.Write("{ "); for(int i = 0; i < size; i++) { Console.Write(array[i] + "; "); } Console.WriteLine(" }");

Console.WriteLine("\n 1 - отсортировать массив методом пузырька" +

"\n 2 - отсортировать массив методом вставки" + "\n 3 - найти элемент в массиве" + "\n 4 - заменить элементы массива");

Console.Write("Введите цифру, соответствующую требуемому действию:"); what_to_do = Console.ReadLine();

switch(what_to_do) { case "1":

Do.sorting_bubble(array, size); break; case "2": Do.sorting_insert(array, size); break;

case "3": Console.Write("Введие число для поиска в массиве:");

for_find = Int32.Parse(Console.ReadLine()); Console.Write(Do.search(array, for_find, size)); break;

case "4": Console.Write("Найти число:"); for_find = Int32.Parse(Console.ReadLine());

Console.Write("Заменить на:"); for_replace = Int32.Parse(Console.ReadLine());

Do.replace(array, for_find, for_replace, size); break; default:

Console.WriteLine("Требовалось ввести 1,2,3 или 4..."); break;

} Console.Write("\nДля выхода из программы нажмите [Enter]:"); string anykey = Console.ReadLine();

} } }

6) Исключительные ситуации. Исключительная ситуация (или исключение) - это ошибка, которая возникает во время выполнения программы. Используя С#-подсистему обработки исключительных ситуаций, с такими ошибками можно справляться. Эта подсистема в С# включает в себя усовершенствованные методы, используемые в языках C++ и Java. Преимущество подсистемы обработки исключений состоит в автоматизации создания большей части кода, который ранее необходимо было вводить в программы "вручную". Обработка исключений упрощает "работу над ошибками", позволяя в программах определять блок кода, именуемый обработчиком исключении, который будет автоматически выполняться при возникновении определенной ошибки. В этом случае не обязательно проверять результат выполнения каждой конкретной операции или метода вручную. Если ошибка возникнет, ее должным образом обработает обработчик исключений. Еще одним преимуществом обработки исключительных ситуаций в С# является определение стандартных исключений для таких распространенных программных ошибок, как деление на нуль или попадание вне диапазона определения индекса. Чтобы отреагировать на возникновение таких ошибок, программа должна отслеживать и обрабатывать эти исключения. Без знания возможностей С#-подсистемы обработки исключений успешное программирование на С# попросту невозможно. В С# исключения представляются классами. Все классы исключений должны быть выведены из встроенного класса исключений Exception, который является частью

пространства имен System. Таким образом, все исключения - подклассы класса Exception. Программные инструкции, которые нужно проконтролировать на предмет исключений, помещаются в try-блок. Если исключение таки возникает в этом блоке, оно дает знать о себе выбросом определенного рода информации. Это выброшенное исключение может быть перехвачено программным путем с помощью catch-блока и обработано соответствующим образом. Системные исключения автоматически генерируются С#-системой динамического управления. Чтобы сгенерировать исключение вручную, используется ключевое слово throw. Любой код, который должен быть обязательно выполнен при выходе из try-блока, помещается в блок finally.

Ядром обработки исключений являются блоки try и catch. Эти ключевые слова работают "в одной связке"; нельзя использовать слово try без catch или catch без try. Вот каков формат записи try/catch-блоков обработки исключений:

try { // Блок кода, подлежащий проверке на наличие ошибок. } catch (ExcepTypel exOb) { // Обработчик для исключения типа ExcepTypel } catch (ExcepType2 exOb) { // Обработчик для исключения типа ЕхсерТуре2 }

Здесь ЕхсерТуре - это тип сгенерированного исключения. После "выброса" исключение перехватывается соответствующей инструкцией catch, которая его обрабатывает. Как видно из формата записи try/catch-блоков, с try-блоком может быть связана не одна, а несколько catch-инструкций. Какая именно из них будет выполнена, определит тип исключения. Другими словами, будет выполнена та catch-инструкция, тип исключения которой совпадает с типом сгенерированного исключения (а все остальные будут проигнорированы). После перехвата исключения параметр exOb примет его значение. Задавать параметр exOb необязательно. Если обработчику исключения не нужен доступ к объекту исключения (как это часто бывает), в задании параметра exOb нет необходимости. Поэтому во многих примерах этой главы параметр exOb не задан. Важно понимать следующее: если исключение не генерируется, то try-блок завершается нормально и все его catch-инструкции игнорируются. Выполнение программы продолжается с первой инструкции, которая стоит после последней инструкции catch. Таким образом, catch-инструкция (из предложенных после try-блока) выполняется только в случае, если сгенерировано соответствующее исключение.

Наиболее употребительные исключения, определенные в пространстве имен System:

Исключение Значение ArrayTypeMismatchException Тип сохраняемого значения несовместим с типом массива DivideByZeroException Попытка деления на нуль IndexOutOfRangeException Индекс массива оказался вне диапазона InvalidCastException Неверно выполнено динамическое приведение типов OutofMemoryException Недостаточный объем свободной памяти OverflowException Имеет место арифметическое переполнение NullReferenceException Попытка использовать нулевую ссылку StackoverflowException Переполнение стека

Иногда требуется перехватывать все исключения, независимо от их типа. Для этого используйте catch-инструкцию без параметров. В этом случае создается обработчик "глобального перехвата", который используется, чтобы программа гарантированно обработала все исключения.

Задание: оптимизировать программу, производящую простые арифметические операции над числами (сложение, вычитание, умножение и деление), используя обработку исключительных ситуаций (обработка ввода чисел и операции деления).

Пример:

using System;

namespace ConsoleApplication { class OurClass { static void Main(string[] args) {

float num1 = 1, num2 = 2, summarize, multiply, sub, divide = 0; Console.Write("Введите первое число:"); try { num1 = float.Parse(Console.ReadLine()); } catch { Console.WriteLine("Неправильный формат числа!\n"+

"В качестве значения первого числа будет 1"); } Console.Write("Введите второе число:"); try { num2 = float.Parse(Console.ReadLine()); }

catch { Console.WriteLine("Неправильный формат числа!\n"+

"В качестве значения второго числа будет 2"); } summarize = num1 + num2; multiply = num1 * num2; sub = num1 - num2; try { divide = num1 / num2; } catch(DivideByZeroException) { Console.WriteLine("Нельзя делить на нуль!"); }

Console.WriteLine( "\n" + num1 + " + " + num2 + " = " + summarize +

"\n" + num1 + " * " + num2 + " = " + multiply + "\n" + num1 + " - " + num2 + " = " + sub + "\n" + num1 + " / " + num2 + " = " + divide);

Console.Write("\nДля выхода из программы нажмите [Enter]:"); string anykey = Console.ReadLine(); } } }

7) Список используемой литературы.

1) Герберт Шилдт “Полный справочник по С#” - М.: Вильямс, 2004 2) Эндрю Троелсен “С# и платформа .NET” - СПб.: Питер, 2004

комментарии (0)

Здесь пока нет комментариев

Ваш комментарий может быть первым

Это только предварительный просмотр

3 страница на 19 страницах

Скачать документ