МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РОССИЙСКОЙ ФЕДЕРАЦИИ
ФЕДЕРАЛЬНОЕ АГЕНТСТВО ПО ОБРАЗОВАНИЮ
ГОСУДАРСТВЕННОЕ ОБРАЗОВАТЕЛЬНОЕ УЧРЕЖДЕНИЕ
ВЫСШЕГО И ПРОФЕССИОНАЛЬНОГО ОБРАЗОВАНИЯ
ТЮМЕНСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ
ИНСТИТУТ МАТЕМАТИКИ И КОМПЬЮТЕРНЫХ НАУК
КАФЕДРА ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
Курсовая работа
Встроенные типы C#
Выполнила:
студентка 398 гр.
Руководитель:
ассистент кафедры ПО
Тюмень-2011
СОДЕРЖАНИЕ
Введение …………………………………………………………….…………………………...4
Глава 1. Встроенные типы C#.....................................................................................................5
1. Целочисленные типы……………………………………………………………………5
2. Типы для представления чисел с плавающей точкой ………………………………...7
3. Десятичный тип данных……………..………………………………………………….8
4. Символы………………………………………………………………………………...10
5. Логический тип данных………………………………………………………………..11
6. Строки………………………………………………………………………...…………12
6.1 Строковый тип………………………………………………………………….12
6.2 Построение строк……………………………………………………………….12
6.3 Обращение со строками……………………………………………………...…13
6.4 Постоянство строк………………………………………………………………15
7. Тип object……………………………………………………………………………..…16
Глава 2. Практическое задание………………………………………………………….……18
Заключение……………………………………………………………………………….……23
Список используемой литературы………………………………………..…………….……24
Аннотация
Целью данной курсовой работы является ознакомление со встроенными типами данных языка программирования C #.
Первая глава посвящена типам данных. В С# имеются две общие категории встроенных типов данных: типы значений и ссылочные типы. Встроенные типы значения являются целочисленными типами(sbyte, byte, char, short, ushort, int, uint, long, ulong), типами с плавающей запятой(float, double) и типами decimal и bool. Встроенные типы ссылок – это string и object.
Во второй главе приведен алгоритм для построения графика произвольной функции, в которой пользователь с клавиатуры вводит функцию и границы изменения переменной и функции.
Введение
C# - язык со строгим контролем типов данных – все операции в C# контролируются компилятором на предмет совместимости типов данных, если операция является недопустимой, то она не будет компилироваться.
Это помогает предотвратить ошибки и повышает надежность. Для этого всем переменным, результатам вычислений выражений и значениям задан определенный тип. Более того, тип значения определяет виды операций, которые разрешено производить над ним. Операция, разрешенная для одного типа данных, может быть запрещена для другого типа.
В С# имеются две общие категории встроенных типов данных: типы значений и ссылочные типы. Встроенные типы значения являются целочисленными типами(sbyte, byte, char, short, ushort, int, uint, long, ulong), типами с плавающей запятой(float, double) и типами decimal и bool. Встроенные типы ссылок – это string и object.
Глава 1. Встроенные типы C#
1. Целочисленные типы
В С# определены девять целочисленных типов: char, byte, sbyte, short, ushort, int, uint, long и ulong. Но тип char применяется, главным образом, для представления символов и поэтому рассматривается далее в этой главе. Остальные восемь целочисленных типов предназначены для числовых расчетов. В таблице 1 представлены их диапазон представления чисел и разрядность в битах.
Таблица 1. Целочисленные типы и их диапазоны
Тип | Диапазон | Размер |
sbyte | От -128 до 127 | 8-разрядное целое число со знаком |
byte | От 0 до 255 | 8-разрядное целое число без знака |
short | От до | 16-разрядное целое число со знаком |
ushort | От 0 до | 16-разрядное целое число без знака |
int | Отдо 2 | 32-разрядное целое число со знаком |
uint | От 0 до 4 | 32-разрядное целое число без знака |
long | От 808 до 9 | 64-разрядное целое число со знаком |
ulong | От 0 до | 64-разрядное целое число без знака |
Как следует из приведенной выше таблицы, в С# определены оба варианта различных целочисленных типов: со знаком и без знака. Целочисленные типы со знаком отличаются от аналогичных типов без знака способом интерпретации старшего разряда целого числа. Так, если в программе указано целочисленное значение со знаком, то компилятор С# сгенерирует код, в котором старший разряд целого числа используется в качестве флага знака. Число считается положительным, если флаг знака равен 0, и отрицательным, если он равен 1.
Вероятно, самым распространенным в программировании целочисленным типом является тип int. Переменные типа int нередко используются для управления циклами, индексирования массивов и математических расчетов общего назначения. Когда же требуется целочисленное значение с большим диапазоном представления чисел, чем у типа int, то для этой цели имеется целый ряд других целочисленных типов. Так, если значение нужно сохранить без знака, то для него можно выбрать тип uint, для больших значений со знаком — тип long, а для больших значений без знака — тип ulong. В качестве примера ниже приведена программа, вычисляющая расстояние от Земли до Солнца в дюймах.
Для хранения столь большого значения в ней используется переменная типа long.
// Вычислить расстояние от Земли до Солнца в дюймах.
using System;
class Inches {
static void Main() {
long inches;
long miles;
miles = ; // 93,000,000 миль до Солнца
// 5,280 feet in a mile, 12 inches in a foot.
inches = miles * 5280 * 12;
Console. WriteLine("Расстояние до Солнца: " +
inches + " дюймов.");
}
}
Вот как выглядит результат выполнения этой программы:
Расстояние до Солнца: дюймов.
Самыми мелкими целочисленными типами являются byte и sbyte. Тип byte представляет целые значения без знака в пределах от 0 до 255. Переменные типа byte особенно удобны для обработки исходных двоичных данных, например байтового потока, поступающего от некоторого устройства. А для представления мелких целых значений со знаком служит тип sbyte. Ниже приведен пример программы, в которой переменная типа byte используется для управления циклом, где суммируются числа от 1 до 100.
// Использовать тип byte.
using System;
class Use_byte {
static void Main() {
byte x;
int sum;
sum = 0;
for(x = 1; x <= 100; x++)
sum = sum + x;
Console. WriteLine("Сумма от 1 до 100 равна " + sum);
}
}
Результат выполнения этой программы выглядит следующим образом:
Сумма чисел от 1 до 100 равна 5050
В приведенном выше примере программы цикл выполняется только от 1 до 100, что не превышает диапазон представления чисел для типа byte, и поэтому для управления этим циклом не требуется переменная более крупного типа.
2. Типы для представления чисел с плавающей точкой
Типы с плавающей точкой позволяют представлять числа с дробной частью.
В С# имеются две разновидности типов данных с плавающей точкой: float и double. Они представляют числовые значения с одинарной и двойной точностью соответственно.
Таблица 2. Типы для представления чисел с плавающей точкой и их диапазоны
Тип | Приблизительный диапазон | Точность | Разрядность |
float | От ±1,5e−45 до ±3,4e38 | 7 знаков | 32 бита |
double | От ±5,0e−324 до ±1,7e308 | 15-16 знаков | 64 бита |
В программировании на С# чаще применяется тип double, в частности, потому, что во многих математических функциях из библиотеки классов С#, которая одновременно является библиотекой классов для среды. NET Framework, используются числовые значения типа double. Например, метод Sqrt(), определенный в библиотеке классов System. Math, возвращает значение типа double, которое представляет собой квадратный корень из аргумента типа double, передаваемого данному методу. В приведенном ниже примере программы метод Sqrt() используется для вычисления радиуса окружности по площади круга.
// Определить радиус окружности по площади круга.
using System;
class FindRadius {
static void Main() {
Double r;
Double area;
area = 10.0;
r = Math. Sqrt(area / 3.1416);
Console. WriteLine("Радиус равен " + r);
}
}
Результат выполнения этой программы выглядит следующим образом:
Радиус равен 1.
В приведенном ниже примере программы демонстрируется применение нескольких тригонометрических функций, которые относятся к классу Math и входят в стандартную библиотеку классов С#. Они также оперируют данными типа double. В этом примере на экран выводятся значения синуса, косинуса и тангенса угла, измеряемого в пределах от 0,1 до 1,0 радиана.
// Продемонстрировать применение тригонометрических функций.
using System;
class Trigonometry {
static void Main() {
Double theta; // угол в радианах
for(theta = 0.1; theta <= 1.0; theta = theta + 0.1) {
Console. WriteLine("Синус угла " + theta + " is " +
Math. Sin(theta));
Console. WriteLine("Косинус угла" + theta + " is " +
Math. Cos(theta));
Console. WriteLine("Тангенс угла " + theta + " is " +
Math. Tan(theta));
Console. WriteLine();
}
}
}
Ниже приведена часть результата выполнения данной программы.
Синус угла 0.1 равен 0.
Косинус угла 0.1 равен 0.
Тангенс угла 0.1 равен 0.
Синус угла 0.2 равен 0.
Косинус угла 0.2 равен 0.
Тангенс угла 0.2 равен 0.
Синус угла 0.3 равен 0.
Косинус угла 0.3 равен 0.
Тангенс угла 0.3 равен 0.
…
Для вычисления синуса, косинуса и тангенса угла в приведенном выше примере были использованы стандартные методы Math. Sin(), Math. Cos() и Math. Tan(). Они вызываются с аргументом типа double и возвращают результат того же типа. Вычисляемые углы должны быть указаны в радианах.
3. Десятичный тип данных
Тип decimal предназначен для применения в финансовых расчетах. Этот тип имеет разрядность 128 бит для представления числовых значений в пределах от 1Е-28 до 7,9Е+28. Для обычных арифметических вычислений с плавающей точкой характерны ошибки округления десятичных значений. Эти ошибки исключаются при использовании типа decimal, который позволяет представить числа с точностью до 28 (а иногда и 29) десятичных разрядов. Благодаря тому, что этот тип данных способен представлять десятичные значения без ошибок округления, он особенно удобен для расчетов, связанных с финансами.
Ниже приведен пример программы, в которой тип decimal используется в конкретном финансовом расчете. В этой программе цена со скидкой рассчитывается на основании исходной цены и скидки в процентах.
//Использовать тип decimal для расчета скидки.
using System;
class UseDecimal {
static void Main() {
decimal price;
decimal discount;
decimal discounted_price;
// Рассчитать цену со скидкой.
price = 19.95m;
discount = 0.15m; // норма скидки составляет 15%
discounted_price = price - ( price * discount);
Console. WriteLine("Цена со скидкой: $" + discounted_price);
}
}
Результат выполнения этой программы выглядит следующим образом:
Цена со скидкой: $16.9575
Значения констант типа decimal в приведенном выше примере программы указываются с суффиксом m. Без суффикса m эти значения интерпретировались бы как стандартные константы с плавающей точкой, которые несовместимы с типом данных decimal. Переменной типа decimal можно присвоить целое значение без суффикса m, например 10.
Рассмотрим еще один пример применения типа decimal. В этом примере рассчитывается будущая стоимость капиталовложений с фиксированной нормой прибыли в течение ряда лет.
/*
Применить тип decimal для рачета будущей стоимости
капиталовложений.
*/
using System;
class FutVal {
static void Main() {
decimal amount;
decimal rate_of_return;
int years, i;
amount = 1000.0M;
rate_of_return = 0.07M;
years = 10;
Console. WriteLine("Первоначальные капиталовложения: $" + amount);
Console. WriteLine("Норма прибыли: " + rate_of_return);
Console. WriteLine("В течение " + years + " лет");
for(i = 0; i < years; i++)
amount = amount + (amount * rate_of_return);
Console. WriteLine("Будующая стоимость равна $" + amount);
}
}
Вот как выглядит результат выполнения этой программы:
Первоначальные капиталовложения: $1000
Норма прибыли: 0.07
В течение 10 лет
Будущая стоимость равна $1967.
Результат выполнения приведенной выше программы представлен с точностью до целого ряда десятичных разрядов, т. е. с явным избытком по сравнению с тем, что обычно требуется!
4. Символы
В С# символы представлены 16-разрядным кодом, который называется уникодом (Unicode). В уникоде набор символов представлен настолько широко, что он охватывает символы практически из всех естественных языков на свете. Если для многих естественных языков, в том числе английского, французского и немецкого, характерны относительно небольшие алфавиты, то в ряде других языков, например китайском, употребляются довольно обширные наборы символов, которые нельзя представить 8-разрядным кодом. Для преодоления этого ограничения в С# определен тип char, представляющий 16-разрядные значения без знака в пределах от 0 доПри этом стандартный набор символов в 8-разрядном коде ASCII является подмножеством уникода в пределах от 0 до 127. Следовательно, символы в коде ASCII по-прежнему остаются действительными в С#.
Для того чтобы присвоить значение символьной переменной, достаточно заключить это значение (т. е. символ) в одинарные кавычки. Так, в приведенном ниже фрагменте кода переменной ch присваивается символ X.
char ch;
ch=’X’;
Значение типа char можно вывести на экран с помощью метода WriteLine().
Например, в следующей строке кода на экран выводится значение переменной ch:
Console.WriteLine("Значение ch равно: " + ch) ;
Несмотря на то что тип char определен в С# как целочисленный, его не следует путать со всеми остальными целочисленными типами. Дело в том, что в С# отсутствует автоматическое преобразование символьных значений в целочисленные и обратно. Например, следующий фрагмент кода содержит ошибку:
char ch;
ch = 88; // ошибка, не выйдет
Ошибочность приведенного выше фрагмента кода объясняется тем, что 88 — это целое значение, которое не преобразуется автоматически в символьное. При попытке скомпилировать данный фрагмент кода будет выдано соответствующее сообщение об ошибке.
5. Логический тип данных
Тип bool представляет два логических значения: "истина" и "ложь". Эти логические значения обозначаются в С# зарезервированными словами true и false соответственно. Следовательно, переменная или выражение типа bool будет принимать одно из этих логических значений. Кроме того, в С# не определено взаимное преобразование логических и целых значений. Например, 1 не преобразуется в значение true, a 0 — в значение false.
В приведенном ниже примере программы демонстрируется применение типа bool.
// Продемонстрировать применение типа bool.
using System;
class BoolDemo {
static void Main() {
bool b;
b = false;
Console. WriteLine("b is " + b);
b = true;
Console. WriteLine("b is " + b);
// A bool value can control the if statement.
if(b) Console. WriteLine("Выполняется.");
b = false;
if(b) Console. WriteLine("Не выполняется.");
// Результатом выполнения оператора отношения является логическое значение.
Console. WriteLine("10 > 9 is " + (10 > 9));
}
}
Эта программа дает следующий результат:
b равно False
b равно True
Выполняется.
10 > 9 равно True
В приведенной выше программе обнаруживаются три интересных свойства. Во-первых, при выводе логического значения типа bool с помощью метода WriteLine () на экране появляется значение "True" или "False". Во-вторых, самого значения переменной типа bool достаточно для управления оператором if. Для этого не нужно, например, записывать оператор if следующим образом:
if (b == true
И в-третьих, результатом выполнения оператора отношения является логическое значение. Именно поэтому в результате вычисления выражения 10>9 на экран выводится значение "True." Кроме того, выражение 10>9 следует заключить в скобки, поскольку оператор + имеет более высокий приоритет, чем оператор >.
6. Строки
6.1 Строковый тип
Строковый тип определяет и поддерживает символьные строки. В целом ряде других языков программирования строка представляет собой массив символов. А в С# строки являются объектами. Следовательно, тип string относится к числу ссылочных.
При создании строкового литерала в действительности формируется строковый объект. Например, в следующей строке кода:
Console. WriteLine ("В С# строки являются объектами.");
текстовая строка "В С# строки являются объектами. " автоматически преобразуется в строковый объект средствами С#.
6.2 Построение строк
Самый простой способ построить символьную строку — воспользоваться строковым литералом. Например, в следующей строке кода переменной ссылки на строку str присваивается ссылка на строковый литерал:
string str = "Строки в С# весьма эффективны.";
В данном случае переменная str инициализируется последовательностью символов
"Строки в С# весьма эффективны."
Объект типа string можно также создать из массива типа char. Например:
char[] charray = {'t', 'e', 's', 't'};
string str = new string(charray);
Как только объект типа string будет создан, его можно использовать везде, где только требуется строка текста, заключенного в кавычки. Как показано в приведенном ниже примере программы, объект типа string может служить в качестве аргумента при вызове метода WriteLine ().
// Создать и вывести символьную строку.
using System;
class StringDemo {
static void Main() {
char[] charray = {'Э', 'т', 'о', ' ', 'с', 'т', 'р', 'о', 'к', 'а', '.' };
string str1 = new string(charray);
string str2 = "Еще одна строка.";
Console. WriteLine(str1);
Console. WriteLine(str2);
}
}
Результат выполнения этой программы приведен ниже.
Это строка.
Еще одна строка.
6.3 Обращение со строками
Класс типа string содержит ряд методов для обращения со строками. Некоторые из этих методов перечислены в таблице 3.
Таблица 3. Некоторые общеупотребительные методы обращения со строками
Метод | Описание |
static int Compare(string strA, string strB, StringComparison comparisonType) | Возвращает отрицательное значение, если строка strA меньше строки strB; положительное значение, если строка strA больше строки strB; и нуль, если сравниваемые строки равны. Способ сравнения определяется аргументом comparisonType |
bool Equals(string value, StringComparison comparisonType) | Возвращает логическое значение true, если вызывающая строка имеет такое же значение, как и у аргумента value. Способ сравнения определяется аргументом comparisonType |
int IndexOf(char value) | Осуществляет поиск в вызывающей строке первого вхождения символа, определяемого аргументом value. Применяется порядковый способ поиска. Возвращает индекс первого совпадения с искомым символом или -1, если он не обнаружен |
int IndexOf(string value, StringComparison comparisonType) | .Осуществляет поиск в вызывающей строке первого вхождения подстроки, определяемой аргументом value. Возвращает индекс первого совпадения с искомой подстрокой или -1, если она не обнаружена. Способ поиска определяется аргументом comparisonType |
Отдельный символ выбирается из строки с помощью индекса, как в приведенном ниже фрагменте кода.
string str = "тест";
Console.WriteLine(str[0]);
В этом фрагменте кода выводится символ "т", который является первым в строке "тест". Индексирование строк начинается с нуля. Следует, однако, иметь в виду, что с помощью индекса нельзя присвоить новое значение символу в строке. Индекс может служить только для выборки символа из строки.
Для проверки двух строк на равенство служит оператор ==. Как правило, если оператор == применяется к ссылкам на объект, то он определяет, являются ли они ссылками на один и тот же объект. Совсем иначе обстоит дело с объектами типа string. Когда оператор == применяется к ссылкам на две строки, он сравнивает содержимое этих строк. Это же относится и к оператору!=. При сравнении объектов типа string сравнивается содержимое строк. А для других видов сравнения строк приходится пользоваться методом CompareTo ().
В приведенном ниже примере программы демонстрируется несколько операций со строками.
// Некоторые операции со строками.
using System;
using System. Globalization;
class StrOps {
static void Main() {
string str1 = "Программировать в. NET лучше всего на С#.";
string str2 = "Программировать в. NET лучше всего на С#.";
string str3 = "Строки в С# весьма эффективны.";
string strUp, strLow;
int result, idx;
Console. WriteLine("str1: " + str1);
Console. WriteLine("Длина строки: " + str1.Length);
// Создать варианты строки strl, набранные
// прописными и строчными буквами.
strLow = str1.ToLower(CultureInfo. CurrentCulture);
strUp = str1.ToUpper(CultureInfo. CurrentCulture);
Console. WriteLine("Вариант строки strl, " + "набранный строчными буквами:\n " + strLow);
Console. WriteLine("Вариант строки strl, " + "набранный прописными буквами:\n " + strUp);
Console. WriteLine();
// Вывести строку strl посимвольно.
Console. WriteLine("Вывод строки strl посимвольно.");
for(int i=0; i < str1.Length; i++)
Console. Write(str1[i]);
Console. WriteLine("\n");
// Сравнить строки способом порядкового сравнения.
if(str1 == str2)
Console. WriteLine("str1 == str2");
else
Console. WriteLine("str1 != str2");
if(str1 == str3)
Console. WriteLine("str1 == str3");
else
Console. WriteLine("str1 != str3");
// Сравнить строки с учетом культурной среды.
result = pare(str1, str3, StringComparison. CurrentCulture);
if(result == 0)
Console. WriteLine("Строки strl и str3 равны"); else if(result < 0)
Console. WriteLine("Строка strl-меньше строки str3"); else
Console. WriteLine("Строка strl больше строки str3");
Console. WriteLine();
str2 = "Один Два Три Один";
// Поиск подстроки.
idx = str2.IndexOf("Один", StringComparison. Ordinal);
Console. WriteLine("Индекс первого вхождения подстроки <Один>: " + idx);
idx = str2.LastlndexOf("Один", StringComparison. Ordinal);
Console. WriteLine("Индекс последнего вхождения подстроки <Один>: " + idx) ;
}
}
При выполнении этой программы получается следующий результат:
strl: Программировать в. NET лучше всего на С#.
Длина строки strl: 41
Вариант строки strl, набранный строчными буквами:
программировать в. net лучше всего на с#.
Вариант строки strl, набранный прописными буквами:
программировать в. net лучше всего на с#.
Вывод строки strl посимвольно.
Программировать в. NET лучше всего на С#.
strl == str2
strl!= str3
strl больше str3
Индекс первого вхождения подстроки <Один>: 0
Индекс последнего вхождения подстроки <Один>: 13
С помощью оператора + можно сцепить (т. е. объединить вместе) две строки. Например, в следующем фрагменте кода:
string strl = "Один";
string str2 = "Два";
string str3 = "Три";
string str4 = strl + str2 + str3;
переменная str4 инициализируется строкой "ОдинДваТри".
6.4 Постоянство строк
Содержимое объекта типа string не подлежит изменению. Это означает, что однажды созданную последовательность символов изменить нельзя. Но данное ограничение способствует более эффективной реализации строк. Поэтому этот, на первый взгляд, очевидный недостаток на самом деле превращается в преимущество. Так, если требуется строка в качестве разновидности уже имеющейся строки, то для этой цели следует создать новую строку, содержащую все необходимые изменения.
Следует подчеркнуть, что переменные ссылки на строки подлежат изменению, а следовательно, они могут ссылать на другой объект. Но содержимое самого строкового объекта не меняется после его создания.
Для того чтобы стало понятнее, почему неизменяемые строки не являются помехой, воспользуемся еще одним методом обращения со строками: Substring(). Этот метод возвращает новую строку, содержащую часть вызывающей строки. В итоге создается новый строковый объект, содержащий выбранную подстроку, тогда как исходная строка не меняется, а, следовательно, соблюдается принцип постоянства строк. Ниже приведена
рассматриваемая здесь форма метода Substring().
string Substring(int начало, int длина)
где начало обозначает начальный индекс исходной строки, а длина — длину выбираемой подстроки.
Ниже приведена программа, в которой принцип постоянства строк демонстрируется на примере применения метода Substring().
// Применить метод Substring().
using System;
class SubStr {
static void Main() {
string orgstr = "В С# упрощается обращение со строками.";
// сформировать подстроку
string substr = orgstr. Substring(5, 12);
Console. WriteLine("orgstr: " + orgstr);
Console. WriteLine("substr: " + substr);
}
}
Вот к какому результату приводит выполнение этой программы:
orgstr: В С# упрощается обращение со строками.
substr: упрощается обращение
Исходная строка из переменной orgstr не меняется, а выбранная из нее подстрока содержится в переменной substr.
7. Класс object
Класс object можно вполне использовать в качестве "универсального" типа данных. Для примера рассмотрим программу, в которой сначала создается массив типа object, элементам которого затем присваиваются значения различных типов данных:
// Использовать класс object для создания массива "обобщенного" типа.
using System;
class GenericDemo {
static void Main() {
object[] ga = new object[10];
// Сохранить целые значения.
for(int i=0; i < 3; i++)
ga[i] = i;
// Сохранить значения типа double.
for(int i=3; i < 6; i++)
ga[i] = (double) i / 2;
// Сохранить две строки, а также значения типа bool и char.
ga[6] = "Привет";
ga[7] = true;
ga[8] = 'X';
ga[9] = "Конец";
for(int i = 0; i < ga. Length; i++)
Console. WriteLine("ga[" + i + "]: " + ga[i] + " ");
}
}
Выполнение этой программы приводит к следующему результату:
ga[0]: 0
ga[1]: 1
ga[2]: 2
ga[3]: 1.5
ga[4]: 2
ga[5]: 2.5
ga[6]: Привет
ga[7]: True
ga[8]: X
ga[9]: Конец
Как показывает данный пример, по ссылке на объект класса object можно обращаться к данным любого типа, поскольку в переменной ссылочного типа object допускается хранить ссылку на данные всех остальных типов. Следовательно, в массиве типа object из рассматриваемого здесь примера можно сохранить данные практически любого типа.
Несмотря на то что универсальный характер класса object может быть довольно эффективно использован в некоторых ситуациях, было бы ошибкой думать, что с помощью этого класса стоит пытаться обойти строго соблюдаемый в С# контроль типов. Вообще говоря, целое значение следует хранить в переменной типа int, строку — в переменной ссылочного типа string и т. д.
Глава 2. Практическое задание
Задание: построение графика произвольной функции одной переменой. Уравнение функции и границы изменения переменной и функции вводит пользователь.
Программа обрабатывает следующие операторы: +, -, *, /, ^, %
Функции:
sqrt, sin, cos, tan, atan, acos, asin,
acotan, exp, ln, 10log, fac, sinh, cosh,
tanh, abs, ceil, floor, round, fpart
Максимальное значение функции при построении графика равно 1000, значения переменной могут изменяться от -500 до 500.
Реализация:
using System;
using System. Collections. Generic;
using ponentModel;
using System. Data;
using System. Drawing;
using System. Text;
using System. Windows. Forms;
using System. Text. RegularExpressions;
using System. Diagnostics;
using System. Globalization;
using info. lundin. Math;
using System. Collections;
namespace курсовая
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private const int Npoints = 2000;
Array myArr = Array. CreateInstance(typeof(float), 2 , Npoints);
private void Calculation(Array a)
{
float x_0;
float step_x = (x_max - x_min) / Npoints;
for (int i = 0; i < Npoints; i++)
{
a. SetValue(x_min + i * step_x,0,i);
}
for (int i = 0; i < Npoints; i++)
{
x_0 = x_min + i * step_x;
a. SetValue(-Function_of_graph((float)a. GetValue(0,i), s),1,i);
}
}
public float x_min = 0, x_max = 0; string s = null; bool f=false;
private float Function_of_graph(float x, string s)
{
ExpressionParser parser = new ExpressionParser();
Hashtable h = new Hashtable();
h. Add("x", (x).ToString());
double result;
try
{
result = parser. Parse(s, h);
}
catch
{
result = 0;
f = true;
}
return (float)result;
}
private float O_x_pix = 200, O_y_pix = 200,y_max_abs=0,x_max_abs; int n1=1,n2=1;
private void Maximum_x(out float x)
{
x = Math. Abs(x_min);
if (x < Math. Abs(x_max)) x = Math. Abs(x_max);
if (x <= 20) n1 = 1;
else if ((x_max_abs > 20)&&(x_max_abs<=100)) n1 = 10;
else n1 = 100;
}
private void pictureBox1_Paint(object sender, PaintEventArgs e)
{
float x_0_pix, y_0_pix, x_1_pix, y_1_pix;
Pen greenPen = new Pen(Color. Green, 2);
PointF point1 = new PointF(0, O_y_pix);
PointF point2 = new PointF(400, O_y_pix);
e. Graphics. DrawLine(greenPen, point1, point2);
int N_step_grid_y = (int)y_max_abs * 2/n2;
float step_grid_y_pix;
step_grid_y_pix = (float)200 / y_max_abs*n2;
Pen greenPen1 = new Pen(Color. Green, 1);
int j_y; float y1_pix;
for (j_y = 1; j_y <= y_max_abs/n2; j_y++)
{
y1_pix = O_y_pix + j_y * step_grid_y_pix;
PointF point3 = new PointF(0, y1_pix);
PointF point4 = new PointF(400, y1_pix);
e. Graphics. DrawLine(greenPen1, point3, point4);
}
for (j_y = 1; j_y <= y_max_abs/n2; j_y++)
{
y1_pix = O_y_pix - j_y * step_grid_y_pix;
PointF point5 = new PointF(0, y1_pix);
PointF point6 = new PointF(400, y1_pix);
e. Graphics. DrawLine(greenPen1, point5, point6);
}
PointF point7 = new PointF(O_x_pix, 0);
PointF point8 = new PointF(O_x_pix, 400);
e. Graphics. DrawLine(greenPen, point7, point8);
float span_x = x_max - x_min;
int N_step_grid_x = (int)(x_max - x_min)/n1;
float step_grid_x_pix;
step_grid_x_pix = 200 / x_max_abs*n1;
int j_x; float x1_pix;
for (j_x = 1; j_x <= x_max_abs/n1; j_x++)
{
x1_pix = O_x_pix + j_x * step_grid_x_pix;
PointF point9 = new PointF(x1_pix, 0);
PointF point10 = new PointF(x1_pix, 400);
e. Graphics. DrawLine(greenPen1, point9, point10);
}
for (j_x = 1; j_x <= x_max_abs / n1; j_x++)
{
x1_pix = O_x_pix -j_x * step_grid_x_pix;
PointF point11 = new PointF(x1_pix, 0);
PointF point12 = new PointF(x1_pix, 400);
e. Graphics. DrawLine(greenPen1, point11, point12);
}
int n; double p1; string msg;
for (n = 0; n <= (int)y_max_abs; n+=n2)
{
p1 = n;
msg = p1.ToString();
e. Graphics. DrawString(msg, this. Font, Brushes. Black,
O_x_pix, O_y_pix - n * step_grid_y_pix/n2);
}
for (n = n2; n <= (int)y_max_abs; n += n2)
{
p1 = - n;
msg = p1.ToString();
e. Graphics. DrawString(msg, this. Font, Brushes. Black,
O_x_pix, O_y_pix + n * step_grid_y_pix/n2);
}
for (n = n1; n <= (int)x_max_abs; n += n1)
{
p1 = n;
msg = p1.ToString();
e. Graphics. DrawString(msg, this. Font, Brushes. Black,
O_x_pix + n * step_grid_x_pix/n1, O_y_pix);
}
for (n = n1 ; n<=(int)x_max_abs; n+=n1)
{
p1 = - n;
msg = p1.ToString();
e. Graphics. DrawString(msg, this. Font, Brushes. Black, (x_max_abs - n) * step_grid_x_pix/n1, O_y_pix);
}
Pen blackPen = new Pen(Color. Black, 2);
for (int i = 1; i < Npoints; i++)
{
double f=Convert. ToDouble(myArr. GetValue(1, i));
if ((f >= y_min) && (f <= y_max))
{
try
{
x_0_pix = (float)Convert. ToDouble(myArr. GetValue(0, i - 1)) / x_max_abs * O_x_pix + O_x_pix;
y_0_pix = (float)Convert. ToDouble(myArr. GetValue(1, i - 1)) / y_max_abs * O_y_pix + O_y_pix;
x_1_pix = (float)Convert. ToDouble(myArr. GetValue(0, i)) / x_max_abs * O_x_pix + O_x_pix;
y_1_pix = (float) f / y_max_abs * O_y_pix + O_y_pix;
try
{
e. Graphics. DrawLine(blackPen, x_0_pix, y_0_pix, x_1_pix, y_1_pix);
}
catch
{
continue;
}
}
catch { continue; }
}
else continue;
}
}
float y_min, y_max;
private void button1_Click(object sender, EventArgs e)
{
f=false;
s = textBox1.Text;
float y = Function_of_graph(0, s);
if (f) MessageBox. Show("!!!функция введена направильно!!!");
else
{
try
{
x_min = (float)Convert. ToDouble(textBox2.Text);
x_max = (float)Convert. ToDouble(textBox3.Text);
}
catch
{
textBox2.Text = "-5";
textBox3.Text = "5";
x_min = -5;
x_max = 5;
}
try
{
y_max =-(float)Convert. ToDouble(textBox4.Text);
y_min =-(float)Convert. ToDouble(textBox5.Text);
}
catch
{
textBox4.Text = "-5";
textBox5.Text = "5";
y_min = -5;
y_max = 5;
}
if (x_min >= x_max)
{
MessageBox. Show("введите значения х верно!(x_min < x_max)");
}
else
if (!((Math. Abs(x_min) > 500) || (Math. Abs(x_max) > 500)))
if (y_min >= y_max)
{
MessageBox. Show("введите значения y верно!(y_min < y_max)");
}
else if (!((Math. Abs(y_min) > 1000) || (Math. Abs(y_max) > 1000)))
{
Maximum_x(out x_max_abs);
Calculation(myArr);
if (Math. Abs((double)y_min) < Math. Abs((double)y_max)) y_max_abs = (float)Math. Abs((double)y_max); else y_max_abs = (float)Math. Abs((double)y_min);
if (y_max_abs <= 20) n2 = 1;
else if ((y_max_abs > 20) && (y_max_abs <= 100)) n2 = 10;
else n2 = 100;
pictureBox1.Invalidate();
}
else { MessageBox. Show("у изменяется от -1000 до 1000"); }
else { MessageBox. Show("x изменяется от -500 до 500"); }
}
}
private void button2_Click(object sender, EventArgs e)
{
MessageBox. Show("Operators: \n +, -, *, /, ^, % \n Functions: \n sqrt, sin, cos, tan, atan, acos, asin, \n acotan, exp, ln, 10log, fac, sinh, cosh,\n tanh, abs, ceil, floor, sfac, round, fpart");
}
}
}
Техническое описание программы
Для начала работы с C# необходимо поставить. NET Framework на свой компьютер. Скачать соответствующую версию можно c http://msdn. /net/ (около 108 мб).
Систменые требования: Windows 95/98/ME/2000/XP; Pentium II 350/500 МГц; 64/128 Мб оперативной памяти; не менее 10 Мб свободного места на диске.
Заключение
В данной курсовой работе рассмотрены все встроенные типы C#. Они делятся на типы-значения и типы-ссылки. Встроенные типы значения являются целочисленными типами(sbyte, byte, char, short, ushort, int, uint, long, ulong), типами с плавающей запятой(float, double) и типами decimal и bool. Встроенные типы ссылок – это string и object. На примерах рассмотрено применение всех этих типов.
Выполнено практическое задание. Представлен код реализации программы построения графика произвольной функции.
Список используемой литературы
1. Жарков графика, мультимедиа и игры на 2005. – М.: Жарков Пресс, 2005. – 812с.
2. Шилдт, Герберт. С# 4.0: полное руководство. : Пер. с англ. – М. : . Д. Вильямс», 2011. – 1056 с.
3. C# в подлиннике: Пер. с англ./ Дейтел. Х., Листфилд Дж., – СПб.: БХВ-Петербург, 2006. – 1056 с.
4. http://msdn. /ru-ru/library/ms173104(VS.90).aspx
5. http://lundin. info/blog/2010/11/14/info-lundin-math-for-net/
