355 500 произведений, 25 200 авторов.

Электронная библиотека книг » Герберт Шилдт » C# 4.0: полное руководство » Текст книги (страница 4)
C# 4.0: полное руководство
  • Текст добавлен: 6 апреля 2017, 04:00

Текст книги "C# 4.0: полное руководство"


Автор книги: Герберт Шилдт



сообщить о нарушении

Текущая страница: 4 (всего у книги 83 страниц)

Точка с запятой и оформление исходного текста программы

В C# точка с запятой обозначает конец оператора. Это означает, что каждый оператор в отдельности должен оканчиваться точкой с запятой.

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

В C# конец строки не означает конец оператора – о его окончании свидетельствует только точка с запятой. Именно поэтому оператор можно поместить в любой части строки. Например, на языке C# строки кода

X = у;

у = у + 1;

Console.WriteLine(х + " " + у);

означают то же самое, что и строка кода

х = у; у = у + 1; Console.WriteLine(х + " " + у);

Более того, составные элементы оператора можно располагать в отдельных строках. Например, следующий фрагмент кода считается в C# вполне допустимым.

Console.WriteLine(«Это длинная строка вывода» +

          х + у + z +

          «дополнительный вывод»);

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

Возможно, вы уже обратили внимание на то, что в предыдущих примерах программ некоторые операторы были набраны с отступом. В C# допускается свободная форма записи. Это означает, что взаимное расположение операторов в строке не имеет особого значения. Но с годами в программировании сложился общепринятый стиль оформления исходного текста программ с отступами, что существенно облегчает чтение этого текста. Именно этому стилю следуют примеры программ в данной книге, что рекомендуется делать и вам. В соответствии с этим стилем следует делать отступ (в виде нескольких пробелов) после каждой открывающей фигурной скобки и возвращаться назад после закрывающей фигурной скобки. А для некоторых операторов даже требуется дополнительный отступ, но об этом речь пойдет далее.


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

Основу любого языка программирования составляют его ключевые слова, поскольку они определяют средства, встроенные в этот язык. В C# определены два общих типа ключевых слов: зарезервированные и контекстные. Зарезервированные ключевые слова нельзя использовать в именах переменных, классов или методов. Их можно использовать только в качестве ключевых слов. Именно поэтому они и называются зарезервированными. Их иногда еще называют зарезервированными словами, или зарезервированными идентификаторами. В настоящее время в версии 4.0 языка C# определено 77 зарезервированных ключ^евых слов (табл. 2.1).

Таблица 2.1. Ключевые слова, зарезервированные в языке C#

abstract

as

base

bool

break

byte

case

catch

char

checked

class

const

continue

decimal

default

delegate

do

double

else

enum

event

explicit

extern

false

finally

fixed

float

for

foreach

goto

if

implicit

in

int

interface

internal

is

lock

long

namespace

new

null

object

operator

out

override

params

private

protected

public

readonly

ref

return

sbyte

sealed

short

sizeof

stackalloc

static

string

struct

switch

this

throw

true

try

typeof

uint

ulong

unchecked

unsafe

ushort

using

virtual

volatile

void

while

Кроме того, в версии C# 4.0 определены 18 контекстных ключевых слов, которые приобретают особое значение в определенном контексте. В таком контексте они выполняют роль ключевых слов, а вне его они могут использоваться в именах других элементов программы, например в именах переменных. Следовательно, контекстные ключевые слова*формально не являются зарезервированными. Но, как правило, их следует считать зарезервированными, избегая их применения в любых других целях. Ведь применение контекстного ключевого слова в качестве имени какого-нибудь другого элемента программы может привести к путанице, и поэтому считается многими программистами плохой практикой. Контекстные ключевые слова приведены в табл. 2.2.

Таблица 2.2. Контекстные ключевые слова в C#

add

dynamic

from

get

global

group

into

join

let

orderby

partial

remove

select

set

value

var

where

yield


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

В C# идентификатор представляет собой имя, присваиваемое методу, переменной или любому другому определяемому пользователем элементу программы. Идентификаторы могут состоять из одного или нескольких символов. Имена переменных могут начинаться с любой буквы алфавита или знака подчеркивания. Далее может следовать буква, цифра или знак подчеркивания. С помощью знака подчеркивания можно повысить удобочитаемость имени переменной, как, например, line_count. Но идентификаторы, содержащие два знака подчеркивания подряд, например, max_value,

зарезервированы для применения в компиляторе. Прописные и строчные буквы в C# различаются. Так, например myvar и MyVar – это разные имена переменных. Ниже приведены некоторые примеры допустимых идентификаторов.

Test

X

У2

MaxLoad

up

top

my_var

sample23

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

Несмотря на то что зарезервированные ключевые слова нельзя использовать в качестве идентификаторов, в C# разрешается применять ключевое слово с предшествующим знаком @ в качестве допустимого идентификатора. Например, @for – действительный идентификатор. В этом случае в качестве идентификатора фактически служит ключевое слово for, а знак @ просто игнорируется. Ниже приведен пример программы, демонстрирующей применение идентификатора со знаком @.

// Продемонстрировать применение идентификатора со знаком

using System;

class IdTest {

static void Main() {

  int @if; // применение ключевого слова if

  //в качестве идентификатора

  for(@if = 0; @if < 10; @if++)

    Console.WriteLine ( "@if равно " + @if) ;

  }

}

Приведенный ниже результат выполнения этой программы подтверждает, что @if правильно интерпретируется в качестве идентификатора.

@if равно 0

@if равно 1

@if равно 2

@if равно 3

@if равно 4

@if равно 5

@if равно 6

@if равно 7

@if равно 8

@if равно 9

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


Библиотека классов среды .NET Framework

В примерах программ, представленных в этой главе, применялись два встроенных метода: WriteLine() и Write(). Как упоминалось выше, эти методы являются членами класса Console, относящегося к пространству имен System, которое определяется в библиотеке классов для среды .NET Framework. Ранее в этой главе пояснялось, что среда C# опирается на библиотеку классов, предназначенную для среды .NET Framework, чтобы поддерживать операции ввода-вывода, обработку строк, работу в сети и графические пользовательские интерфейсы. Поэтому, вообще говоря, C# представляет собой определенное сочетание самого языка C# и стандартных классов .NET. Как будет показано далее, библиотека классов обеспечивает функциональные возможности, являющиеся неотъемлемой частью любой программы на С#. Для того чтобы научиться программировать на С#, нужно знать не только сам язык, но и уметь пользоваться стандартными классами. Различные элементы библиотеки классов для среды .NET Framework рассматриваются в части I этой книги, а в части II – сама библиотека по отдельным ее составляющим.

ГЛАВА 3 Типы данных, литералы и переменные

В этой главе рассматриваются три основополагающих элемента С#: типы данных, литералы и переменные.

В целом, типы данных, доступные в языке программирования, определяют те виды задач, для решения которых можно применять данный язык. Как и следовало ожидать, в C# предоставляется богатый набор встроенных типов данных, что делает этот язык пригодным для самого широкого применения. Любой из этих типов данных может служить для создания переменных и констант, которые в языке C# называются литералами.


О значении типов данных

Типы данных имеют особенное значение в С#, поскольку это строго типизированный язык. Это означает, что все операции подвергаются строгому контролю со стороны компилятора на соответствие типов, причем недопустимые операции не компилируются. Следовательно, строгий контроль типов позволяет исключить ошибки и повысить надежность программ. Для обеспечения контроля типов все переменные, выражения и значения должны принадлежать к определенному типу. Такого понятия, как «бестиповая» переменная, в данном языке программирования вообще не существует. Более того, тип значения определяет те операции, которые разрешается выполнять над ним. Операция, разрешенная для одного типа данных, может оказаться не-. допустимой для другого.

ПРИМЕЧАНИЕ

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


Типы значений в C#

В C# имеются две общие категории встроенных типов данных: типы значений и ссылочные типы. Они отличаются по содержимому переменной. Если переменная относится к типу значения, то она содержит само значение, например 3,1416 или 212. А если переменная относится к ссылочному типу, то она содержит ссылку на значение. Наиболее распространенным примером использования ссылочного типа является класс, но о классах и ссылочных типах речь пойдет далее в этой книге. А здесь рассматриваются типы значений.

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

Таблица. 3.1. Типы значений в C#

Тип        Значение

bool       Логический, предоставляет два значения: “истина” или “ложь”

byte       8-разрядный целочисленный без знака

char       Символьный

decimal     Десятичный (для финансовых расчетов)

double     С плавающей точкой двойной точности

float      С плавающей точкой одинарной точности

int        Целочисленный

long       Длинный целочисленный

sbyte      8-разрядный целочисленный со знаком

short      Короткий целочисленный

uint       Целочисленный без знака

ulong      Длинный целочисленный без знака

ushort     Короткий целочисленный без знака

В C# строго определены пределы и характер действия каждого типа значения. Исходя из требований к переносимости программ, C# не допускает в этом отношении никаких компромиссов. Например, тип int должен быть одинаковым во всех средах выполнения. Но в этом случае отпадает необходимость переписывать код для конкретной платформы. И хотя строгое определение размерности типов значений может стать причиной незначительного падения производительности в некоторых средах, эта мера необходима для достижения переносимости программ.

ПРИМЕЧАНИЕ

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


Целочисленные типы

В C# определены девять целочисленных типов: char, byte, sbyte, short, ushort, int, uint, long и ulong. Но тип char применяется, главным образом, для представления символов и поэтому рассматривается далее в этой главе. Остальные восемь целочисленных типов предназначены для числовых расчетов. Ниже представлены их диапазон представления чисел и разрядность в битах.

Тип    Разр.(бит) Диапазон представления чисел

byte   8          0 – 255

sbyte  8          -128 – +127

short  16          -32768 – +32767

ushort 16         0 – 65535

int    32         -2147483648 – +2147483647

uint   32         0 – 4294967295

long   64         -9223372036854775808 – +9223372036854775807

ulong  64         0 – 18446744073709551615

Как следует из приведенной выше таблицы, в C# определены оба варианта различных целочисленных типов: со знаком и без знака. Целочисленные типы со знаком отличаются от аналогичных типов без знака способом интерпретации старшего разряда целого числа. Так, если в программе указано целочисленное значение со знаком, то компилятор C# сгенерирует код, в котором старший разряд целого числа используется в качестве флага знака. Число считается положительным, если флаг знака равен 0, и отрицательным, если он равен 1. Отрицательные числа практически всегда представляются методом дополнения до двух, в соответствии с которым все двоичные разряды отрицательного числа сначала инвертируются, а затем к этому числу добавляется 1.

Целочисленные типы со знаком имеют большое значение для очень многих алгоритмов, но по абсолютной величине они наполовину меньше своих аналогов без знака. Вот как, например, выглядит число 32 767 типа short в двоичном представлении.

0111111111111111

Если установить старший разряд этого числа равным 1, чтобы получить значение со знаком, то оно будет интерпретировано как -1, принимая во внимание формат дополнения до двух. Но если объявить его как значение типа ushort, то после установки в 1 старшего разряда оно станет равным 65 535.

Вероятно, самым распространенным в программировании целочисленным типом является тип int. Переменные типа int нередко используются для управления циклами, индексирования массивов и математических расчетов общего назначения. Когда же требуется целочисленное значение с большим диапазоном представления чисел, чем у типа int, то для этой цели имеется целый ряд других целочисленных типов. Так, если значение нужно сохранить без знака, то для него можно выбрать тип uint, для больших значений со знаком – тип long, а для больших значений без знака – тип ulong. В качестве примера ниже приведена программа, вычисляющая расстояние от Земли до Солнца в дюймах. Для хранения столь большого значения в ней используется переменная типа long.

// Вычислить расстояние от Земли до Солнца в дюймах.

using System;

class Inches {

  static void Main() {

    long inches;

    long miles;

    miles = 93000000; // 93 000 000 миль до Солнца

    // 5 280 футов в миле, 12 дюймов в футе,

    inches = miles * 5280 * 12;

    Console.WriteLine("Расстояние до Солнца: " + inches + « дюймов.»);

  }

}

Вот как выглядит результат выполнения этой программы.

Расстояние до Солнца: 5892480000000 дюймов.

Очевидно, что этот результат нельзя было бы сохранить в переменной типа int или uint.

Самыми мелкими целочисленными типами являются 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, и поэтому для управления этим циклом не требуется переменная более крупного типа.

Если же требуется целое значение, большее, чем значение типа byte или sbyte, но меньшее, чем значение типа int или uint, то для него можно выбрать тип short или ushort.


Типы для представления чисел с плавающей точкой

Типы с плавающей точкой позволяют представлять числа с дробной частью. В C# имеются две разновидности типов данных с плавающей точкой: float и double. Они представляют числовые значения с одинарной и двойной точностью соответственно. Так, разрядность типа float составляет 32 бита, что приближенно соответствует диапазону представления чисел от 5Е-45 до 3,4Е+38. А разрядность типа double составляет 64 бита, что приближенно соответствует диапазону представления чисел от 5Е-324 до

1,7Е+308.

В программировании на C# чаще применяется тип 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.78412203012729

В приведенном выше примере программы следует обратить внимание на вызов метода Sqrt(). Как упоминалось выше, метод Sqrt() относится к классу Math, поэтому в его вызове имя Math предшествует имени самого метода. Аналогичным образом имя класса Console предшествует имени метода WriteLine() в его вызове. При вызове некоторых, хотя и не всех, стандартных методов обычно указывается имя их класса, как показано в следующем примере.

В следующем примере программы демонстрируется применение нескольких тригонометрических функций, которые относятся к классу 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 +

                        " i равен " + Math.Sin(theta));

      Console.WriteLine("Косинус угла " + theta +

                        " равен " + Math.Cos(theta));

      Console.WriteLine("Тангенс угла " + theta +

                        " равен " + Math.Tan(theta));

      Console.WriteLine();

    }

  }

}

Ниже приведена лишь часть результата выполнения данной программы.

Синус угла 0.1 равен 0.0998334166468282

Косинус угла 0.1 равен 0.995004165278026

Тангенс угла 0.1 равен 0.100334672085451

Синус угла 0.2 равен 0.198669330795061

Косинус угла 0.2 равен 0.980066577841242

Тангенс угла 0.2 равен 0.202710035508673

Синус угла 0.3 равен 0.29552020666134

Косинус угла 0.3 равен 0.955336489125606

Тангенс угла 0.3 равен 0.309336249609623

Для вычисления синуса, косинуса и тангенса угла в приведенном выше примере были использованы стандартные методы Math.Sin(), Math.Cos() и Math.Tan(). Как и метод Math.Sqrt(), эти тригонометрические методы вызываются с аргументом типа double и возвращают результат того же типа. Вычисляемые углы должны быть указаны в радианах.


Десятичный тип данных

Вероятно, самым интересным среди всех числовых типов данных в C# является тип 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 можно присвоить целое значение без суффикса т, например 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.151357289565322490000

Обратите внимание на то, что результат выполнения приведенной выше программы представлен с точностью до целого ряда десятичных разрядов, т.е. с явным избытком по сравнению с тем, что обычно требуется! Далее в этой главе будет показано, как подобный результат приводится к более «привлекательному» виду.


    Ваша оценка произведения:

Популярные книги за неделю