Базовые типы данных языка C#




Базовые (системные или типы значений) типы данных языка C#


Содержание


Поиск на других ресурсах:

1. Какие основные (базовые) типы данных реализованы в языке C#?

В языке C# реализованы следующие базовые типы данных:

  1. Целые типы: sbyte, byte, short, ushort, int, uint, long, ulong.
  2. Типы, в которых сохраняются данные с плавающей запятой (соответствуют вещественному типу): float, double, decimal.
  3. Символьный тип: char.
  4. Логический тип: bool.
  5. Строчный тип: string.

   


2. Какие особенности использования целочисленных типов данных?

В C# есть следующие целочисленные типы данных:

sbyte, byte, short, ushort, int, uint, long, ulong.

Данные таких типов представляют значения из множества целых чисел. Например: -200, 8938, 1134448348.

Символы u перед названиями некоторых типов есть сокращением от слова unsigned. Это означает, что значение переменных этих типов есть без знака, то есть сохранять отрицательные числа в переменных этих типов нельзя.

Переменные типы sbyte и byte занимают 1 байт в памяти компьютера. Переменные типа short и ushort2 байта. Переменные типа int и uint4 байта. Переменные типа long и ulong8 байт.

   


3. Как в программе описать переменную с именем d целого типа int?

Ответ:

int d;

После такого описания под переменную с именем d будет выделено 4 байта памяти компьютера.

   


4. Как в переменную d целого типа ulong занести число 398?

Для присвоения переменной некоторого значения используется оператор присваивания, который обозначается оператором ‘=’.

Ответ 1. Присваивание значения переменной после ее описания.

ulong d;
d = 398;

Ответ 2. Присваивание значения переменной во время ее описания (начальная инициализация).

ulong d = 398;

   


5. Как программно определить размер переменной заданного типа?

Чтобы определить размер переменной используется операция sizeof():

int d;
d = sizeof(sbyte); // d = 1
d = sizeof(short); // d = 2
d = sizeof(int);   // d = 4
d = sizeof(long);  // d = 8

Таким способом можно определить размер в байтах переменной любого базового типа.

   


6. Какие особенности типов данных с плавающей запятой (вещественных типов)?

Типы данных с плавающей запятой оперируют числовыми значениями из множества вещественных чисел. В языке C# есть три основных типа данных для представления чисел с плавающей запятой (вещественных чисел):

  • float — реализует числа одинарной точности. Этот тип является псевдонимом класса System.Single;
  • double — реализует числа двойной точности. Этот тип соответствует классу System.Double;
  • decimal — предназначен для выполнения вычислений, требующих особой точности в представлении дробной части числа, а также минимизации ошибок округления. Тип данных decimal целесообразно применять для финансовых вычислений, где вопрос точности является особенно важным.

Эти типы позволяют сохранять числа с плавающей запятой, например:

2.85
-1000.399
20390239.939

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

1.0/3.0 = 0.33333(3) - число 3 в периоде

При умножении этого числа 0.33333(3) на 3 уже не будет получено первоначальное число 1.0. Таким образом происходит потеря точности. Тип decimal предназначен для уменьшения этих потерь точности за счет увеличения количества разрядов в дробной части числа.

   


7. Как описать переменную соответствующего вещественного типа (с плавающей запятой)?

Пример описания переменных типа float, double, decimal:

float x;
double y;
decimal z;

Здесь описываются три переменные с именами x, y, z. Под переменную x выделяется 4 байта памяти, под переменную y выделяется 8 байт, под переменную z выделяется 16 байт.

   


8. Как программно занести значения в переменную соответствующего вещественного типа?

Пример внесения числовых данных в переменные разных вещественных типов:

float f = (float)9030.939; // начальная инициализация
double d;
decimal z;
d = -392093828.3993;
z = (decimal)390209.3099029;

В данном коде, при внесении данных в переменную f, происходит переведение числового значения 9030.939 в тип float. Так же происходит переведение числа для переменной z в тип decimal. Такое преобразование есть необходимым для вещественных типов float и decimal, так как все числовые значения являются типа double.

   


9. Как определить сколько байт памяти занимает одна переменная типа float, double или decimal?

Чтобы определить это, нужно написать следующий программный код:

int d;
d = sizeof(float);   // d = 4
d = sizeof(double);  // d = 8
d = sizeof(decimal); // d = 16

   


10. Как перевести переменную типа float в тип int?

Для этого используется операция приведения типов. В скобках нужно указать название типа к которому осуществляется приведение.

Пример:

float a;
int b;
a = (float)23.789;
b = (int)a; // b = 23

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

Например, переменная типа short может представлять меньший диапазон чисел, чем переменные типа float, double. В следующем листинге происходит переполнение значения в переменной типа short:

short i;
float f;
f = (float)35748473.8;
i = (short)f;  // i = 31352 - переполнение

   


11. Как перевести переменную из типа int в тип double?

Пример приведения из int в double:

int i;
double d;
i = 3998;
d = (double)i;


12. Какие есть символьные типы данных?

Ответ: char, string

Тип string представляет последовательность символов.

Переменные типа char могут получать значение одного символа. Значение переменной типа char берется в одинарные кавычки, например:

'A'
'4'
';'

Переменная типа char представляет собой одиночный символ Unicode. Такая переменная занимает в памяти компьютера 2 байта.

Переменные типа string – это строки символов, которые взяты в двойные кавычки, например:

"This is a string"

Переменная типа string в C# может иметь любую длину (количество символов).

   


13. Какие особенности использования данных типа char в программе?

Данные типа char представляют символьное значение кода, введенного с клавиатуры. Код символа представляет собой целое число.

Например, код символа ‘s’ равен значению 115.

Фрагмент кода, в котором вычисляется код символа:

int code;
char symbol;
symbol = 's';
code = (int)symbol; // code = 115

То есть, данные типа char есть одними и теми же целыми числами. В языке C# данные типа char занимают в памяти компьютера 2 байта. Язык C# оперирует символами Unicode. Диапазон кодов символов – от 0 до 65535.

   


14. Как в программе по коду символа получить его символьное представление?

Фрагмент программного кода, который переводит код (целое число) в символ (тип char):

int code;
char symbol;
code = 115;
symbol = (char)code; // symbol = 's'

   


15. Какие особенности использования переменных типа string?

Переменные типа string представляют собой строки символов. Максимальная длина строки не ограничена.

Пример описания переменной типа string с именем s1.

string s1;

Пример внесения строки в переменные типа string:

string s1 = "Text-1";
string s2;
s2 = "Text-2";
char c;
c = s2[0]; // Символ с индексом 0. c = 'T'

К переменным типа string можно выполнять различные операции. Подробное описание наиболее распространенных операций с переменными типа string описан здесь.

   


16. Какие особенности использования переменной логического типа bool?

Переменная логического типа bool определяет лишь два состояния: «истина» и «ложь». Переменная типа bool может принимать лишь два значения: true и false.

Пример использования переменной типа bool:

bool b1, b2 = true;
b1 = (6 <= 5); // b1 = false

   


17. Каким образом осуществляется начальная инициализация переменных различных типов?

int d = 231;
float z = (float)-23.15;
char c = 'k';
string s = "Hello!";
double r = -32.593;
bool b = true;

   


18. Каким образом определить максимально допустимое (минимально допустимое) значение переменной определенного типа?

Чтобы определить максимально допустимое или минимально допустимое значение переменной некоторого типа в библиотеке .NET Framework используются свойства MaxValue и MinValue.

Примеры определения предельных значений переменных разных типов.

Для переменных типа int:

// тип int
int i;
int MaxI;
int MinI;
MaxI = int.MaxValue; // MaxI =  2147483647
MinI = int.MinValue; // MinI = -2147483648

Для переменных типа ulong:

// тип ulong
ulong i;
ulong MaxUL;
ulong MinUL;
MaxUL = ulong.MaxValue; // MaxUL = 18446744073709551615
MinUL = ulong.MinValue; // MinUL = 0

Для переменных типа float:

// тип float
float f; float MaxF; 
float MinF; 
MaxF = float.MaxValue; // MaxF = 3.402823E+38
MinF = float.MinValue; // MinF = -3.402823E+38

   


19. Пример, демонстрирующий отличие между типами double и decimal

В нижеследующем примере демонстрируется отличие в округлении между типами double и decimal.

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

  • для типа double результат становится равным 1.0. Это означает, что произошло округление числа 0.3(3) компилятором. Такое округление в некоторых случаях (например, финансовых расчетах) является нежелательным;
  • для типа decimal результат становится равным 0.9(9). Это означает, что обратная операция умножения для типа decimal выполняется без округления. Значит, тип decimal уменьшает ошибки потери точности для вещественных чисел по сравнению с типом double.

Текст демонстрационной программы типа Console Application следующий:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication8
{

  class Program
  {
    static void Main(string[] args)
    {
      // Отличие между типами double и decimal
      // 1. Объявление переменных типов double и decimal
      double dbl; 
      decimal dcm;

      // 2. Деление 1.0/3.0 - происходит потеря точности для обеих типов
      dbl = 1.0 / 3.0; // dbl = 0,333333333333333
      dcm = Decimal.One / (decimal)3.0; // dcm = 0,3333333333333333333333333333

      // 3. Вывод на экран результата деления
      Console.WriteLine("dbl = {0}", dbl);
      Console.WriteLine("dcm = {0}", dcm);

      // 4. Умножение на 3.0
      // тип double делает округление, 
      // то есть происходит потеря точности в этом направлении (при умножении)
      dbl = dbl * 3.0; // dbl = 1.0

      // тип decimal округления не делает, 
      // округления нету, а, значит нету и потери точности
      dcm = dcm * (decimal)3.0; // dcm = 0,9999999999999999999999999999

      // 5. Вывод результата для проверки
      Console.WriteLine("dbl = {0}", dbl);
      Console.WriteLine("dcm = {0}", dcm);

      Console.ReadKey();
    }
  }
}

Результат выполнения программы

dbl = 0,333333333333333
dcm = 0,3333333333333333333333333333
dbl = 1
dcm = 0,9999999999999999999999999999