Заготовка консольной программы .

using System;

namespace ConsoleApplication1

{

class Class1

{

//[STAThread]

static void ]Main(string[ ] args)

{

//основное тело программы

Console.WriteLine(“Любая строка текста”);

}

}

}

Директива using System разрешает использовать имена стандартных классов из пространства имен System непосредственно без указании я пространства. Ключевое слово namespace создает для проекта собственное пространство имен, названное по умолчанию ConsoleApplication1. Это сделано для того, чтобы можно было давать программным объектам имена, не заботясь о том, что они могут совпасть с именами в других пространствах имен.

В языке С# программа представляет собой совокупность взаимодействующих между собой классов. В программе автоматически создан класс с именем Class1. Внутри класса – метод Main(), который обязан присутствовать в любом приложении - с него начинается выполнение программы.

Console – имя стандартного класса из пространства имен System. Его метод WriteLine() выводит на экран заданный в кавычках текст.

8

Все тексты на языке пишутся с помощью его алфавита. Например, в русском языке один алфавит (набор символов), а в албанском — другой. В С# используется кодировка символов Unicode.

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

Существует множество различных кодировок символов. Например, в Windows часто используется кодировка ANSI, в которой каждый символ представляется одним байтом (8 бит), поэтому в этой кодировке можно одновременно задать только 256 символов.

Кодировка Unicode позволяет представить символы всех существующих алфавитов одновременно, что коренным образом улучшает переносимость текстов. Каждому символу соответствует свой уникальный код. Естественно, что при этом для хранения каждого символа требуется больше памяти. Первые 128 Unicode-символов соответствуют первой части кодовой таблицы ANSI.

Алфавит с# включает:

• буквы (латинские и национальных алфавитов) и символ подчеркивания (_) который употребляется наряду с буквами;
• цифры;
• специальные символы, например +, *, { и &;
• пробельные символы (пробел и символы табуляции);
• символы перевода строки.

Из символов составляются более крупные строительные блоки: лексемы, директивы препроцессора и комментарии.

Лексема (token) - это минимальная единица языка, имеющая самостоятельный смысл. Существуют следующие виды лексем:

• имена (идентификаторы);
• ключевые слова;
• знаки операций;
• разделители;
• литералы (константы).

Лексемы языка программирования аналогичны словам естественного языка.

9

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

Идентификаторы

Имена в программах служат той же цели, что и имена в мире людей, - чтобы обращаться к программным объектам и различать их, то есть идентифицировать. Поэтому имена также называют идентификаторами. В идентификаторе могут использоваться буквы, цифры и символ подчёркивания. Прописные и строчные буквы различаются, например, sysop, SySoP, SYSOP – три разных имени.

Первым символом идентификатора может быть буква или знак подчёркивания, но не цифра. Длина идентификатора не ограничена. Пробелы внутри имён не допускаются. В идентификаторах C# разрешается использовать помимо латинских букв буквы национальных алфавитов. Например, Васяявляется правильным идентификатором. Более того, в идентификаторах можно применять даже так называемые escape-последовательности Unicode, то есть представлять символ с помощью его кода в шестнадцатеричном виде с префиксом \u, например, \u00F2.

ПРИМЕЧАНИЕ ———————————————————————————————

Примеры неправильных имён: 2late, Big gig, Б#г; первое начинается с цифры, второе и третье содержат недопустимые символы (пробел и #).

Имена даются элементам программы, к которым требуется обращаться: переменным, типам, константам, методам, меткам и т.д., после этого его можно использовать в последующих операторах программы. При выборе идентификатора необходимо иметь в виду следующее:

• идентификатор не должен совпадать с ключевыми словами;
• не рекомендуется начинать идентификаторы с двух символов подчёркивания, поскольку такие имена зарезервированы для служебного использования.

Ключевые слова

Ключевые слова - это зарезервированные идентификаторы, которые имеют специальное значение для компилятора. Их можно использовать только в том смысле, в котором они определены. Список ключевых слов С# приведен в таблице 2.1.

Знаки операций и разделители

Знак операции — это один или более символов, определяющих действие над операндами. Внутри знака операции пробелы не допускаются. Например, в выражении а+=b знак += является знаком операции, а а и b — операндами. Символы, составляющие знак операций, могут быть как специальными, например, &&, | и <, так и буквенными, такими как as или new.

Операции делятся на унарные, бинарные и тернарную по количеству участвующих в них операндов. Один и тот же знак может интерпретироваться по-разному в зависимости от контекста. Все знаки операций, за исключением [ ], () и?:, представляют собой отдельные лексемы.

Таблица 2.1 - Ключевые слова С#

break

checked

default

ehum

finally

goto

interface

namespace

out

public

sealed

string

true

unchecked

void.bool

char

decimal

else

false

foreach

int

long

operator

protected

sbyte

static

throw

ulong

virtual

base

catch

continue

double

extern

for

in

lock

object

private

return

stackalloc

this

uint

using as

case

const

do

explicit

float

implicit

is

null

params

ref

sizeof

switch

typeof

ushort

while

abstract

byte

class

delegate

event

fixed

if

internal

new

override

readonly

short

struct

try

unsafe

volatil

Разделители используются для разделения или, наоборот, группирования элементов. Примеры разделителей: скобки, точка, запятая. Ниже перечислены все знаки операций и разделители, использующиеся в С#:

{ } [ ] ().,:; + - * / % & | ^! ~ =

< >? ++ -- && << >> ==!= <= >= += -= *= /= %=

&= |= ^= <<= >>= ->

10

Тип данных однозначно определяет:

· Внутреннее представление данных – множество их значений

· Допустимые действия над данными (операции и функции)

Каждое выражение в программе имеет определенный тип. Память, в которой хранятся данные во время выполнения программы, делятся на две области – стек и динамическая память. Стек используется для хранения величин, память под которые выделяет компилятор. В динамической области памяти (heap- куча) память резервируется и освобождается во время выполнения программы с помощью специальных команд самим программистом.

Классификация типов данных в С# представлена на рисунке 3.1

11

Константы и переменные есть основными объектами, которые используются в программе. Константы и переменные – это именованные объекты, для которых выделяется память.

Значение константы обязательно устанавливается при ее объявлении в программе.

В отличие от переменной значение константы не может изменяться программно. Если константа уже объявлена, то при попытке присвоить константе какое-нибудь новое значение компилятор выдаст сообщение об ошибке.

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

Константа объявляется с помощью оператора следующей формы:

const тип имя_константы = значение;

где

const – ключевое слово, которое определяет что именно это есть константа; тип – тип данных, которые сохраняются в константе; имя_константы – имя константы; значение – значение константы, которое есть неизменяемым в программе.

 

Переменные объявляются с помощью оператора следующей формы:

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

где тип – это тип данных, которые сохраняются в переменной; а имя_переменной – это ее имя.

Объявить переменную можно любого типа, который существует в программе. Тип переменной может быть также типом-значением.

 

12

Есть два основных способа преобразования типов:

- Неявное преобразование типов, когда компилятор автоматически конвертирует один фундаментальный тип данных в другой.

- Явное преобразование типов, когда разработчик использует один из операторов casts для выполнения конвертации объекта из одного типа данных в другой.

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

Есть два основных типа неявного преобразования типов:

числовое расширение;

числовая конверсия.

Числовое расширение

Когда значение из одного типа данных конвертируется в другой тип данных побольше (по размеру и по диапазону значений), то это называется числовым расширением. Например, int может быть расширен в long, а float может быть расширен в double:

 

1 2	long l(65); // расширяем значение типа int (65) в тип long double d(0.11f); // расширяем значение типа float (0.11) в тип double

В C++ есть два типа расширений:

Интегральное расширение (или ещё «целочисленное расширение»). Включает в себя преобразование целочисленных типов, меньших, чем int (bool, char, unsigned char, signed char, unsigned short, signed short) в int (если это возможно) или unsigned int.

Расширение типа с плавающей точкой. Конвертация из float в double.

Интегральное расширение и расширение типа с плавающей точкой используются для преобразования «меньших по размеру» типов данных в типы int/unsigned int или double (они наиболее эффективны для выполнения разных операций).

Важно: Числовые расширения всегда безопасны и не приводят к потере данных.

Числовые конверсии

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

 

1 2	double d = 4; // конвертируем 4 (тип int) в double short s = 3; // конвертируем 3 (тип int) в short

В отличие от расширений, которые всегда безопасны, конверсии могут (но не всегда) привести к потере данных. Поэтому, в любой программе, где выполняется неявная конверсия, компилятор будет выдавать предупреждение.

Есть много правил по выполнению числовой конверсии, но мы рассмотрим только основные.

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

 

1 2 3 4 5 6 7 8 9 10 11

#include <iostream>   int main() { int i = 30000; char c = i;   std::cout << static_cast<int>(c);   return 0; }

В этом примере мы присвоили огромное целочисленное значение типа int переменной типа char (диапазон которого составляет от -128 до 127). Это приведёт к переполнению и следующему результату:

48

Однако, если число подходит по диапазону, то конвертация пройдёт успешно. Например:

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include <iostream>   int main() {            int i = 3;            short s = i; // конвертируем значение типа int в тип short            std::cout << s << std::endl;              double d = 0.1234;            float f = d;            std::cout << f << std::endl;              return 0; }

Здесь мы получим ожидаемый результат:

3
0.1234

В случаях со значениями типа с плавающей точкой могут произойти округления из-за худшей точности в меньших типах. Например:

 

1 2 3 4 5 6 7 8 9 10

#include <iostream> #include <iomanip> // для std::setprecision()   int main() {            float f = 0.123456789; // значение типа double - 0.123456789 имеет 9 значащих цифр, но float может хранить только 7            std::cout << std::setprecision(9) << f; // std::setprecision определён в заголовочном файле iomanip              return 0; }

В этом случае мы наблюдаем потерю в точности, так как точность в float меньше чем в double:

0.123456791

Конвертация из типа int в тип float успешна до тех пор, пока значения подходят по диапазону. Например:

 

1 2 3 4 5 6 7 8 9 10

#include <iostream>   int main() {            int i = 10;            float f = i;            std::cout << f;              return 0; }

Результат:

10

Аналогично, конвертация из float в int успешна до тех пор, пока значения подходят по диапазону. Но следует помнить, что любая дробь отбрасывается. Например:

 

1 2 3 4 5 6 7 8 9

#include <iostream>   int main() {            int i = 4.6;            std::cout << i;              return 0; }

Дробная часть значения (.6) игнорируется и результат:

4