Конвертиране на типове

от Уикипедия, свободната енциклопедия
Направо към: навигация, търсене
Конвертиране на типове (Type casting)

Конвертирането на типове е термин в програмирането и означава конвертиране на израз от един тип в друг.[1] При конвертирането на типове се прави, така че една променлива от даден тип да заприлича на променлива от друг тип при дадена конкретна операция. Всеки език за програмиране има свой собствени правила за конвертиране.

Преобразуването на типовете може да се извършва по два основни начина: явно (изрично) и неявно (скрито)[2].

Начини за преобразуване на типове[редактиране | edit source]

Неявно (Скрито)[редактиране | edit source]

Неявното конвертиране на типове се извършва автоматично от компилатора. Обикновено при такава ситуация компилатора предупреждава, че се извършва конвертиране, за да може потребителя да предвиди появата на евентуални грешки или загуба на данни, тъй като решението за конвертиране се прави от компилатора, а не от потребителя. Неявното преобразуване на типове е възможно единствено, когато няма възможност от загуба на данни при преобразуването, т.е. когато конвертираме от тип с по-малък обхват към тип с по-голям обхват.

int x = 123;
double y = x;

Явно (Изрично)[редактиране | edit source]

Явното конвертиране на типове е вид преобразуване на тип на променлива, което е изрично дефинирано в програмата (вместо да се извърши от компилатора за скрито преобразуване на типове). Явното (изричното) конвертиране се използва винаги, когато има вероятност от загуба на данни. Когато конвертираме от тип с плаваща запетая към целочислен тип винаги има загуба на данни, идваща от премахването на дробната част и е задължително използването на явно преобразуване.

double da = 3.4;
double db = 3.3;
double dc = 3.3;
int result = (int)da+(int)db+(int)dc; // result==9
//ако се използва неявно конвертиране ("result = da + db + dc"), резултатът ще бъде равен на 10
Език за програмиране C#

Език за програмиране C#[редактиране | edit source]

[3]C# е статично-типизиран език, т.е. типът на променливата се определя предварително още при нейното деклариране. По този начин програмата работи по-бързо по време на компилиране и също така могат да се избегнат значителен брой грешки. По тази причина, ако имаме веднъж декларирана променлива в C#, то тя не може да бъде декларирана отново или да пази в себе си друг тип стойност.

При неявното конвертиране (type conversion) в C# не се изисква специфичен синтаксис, като в определени случай е достатъчно сигурно, за да няма загуба на данни.

// При неявно конвертиране променлива (число) от тип long може да приема стойности от тип int и т.н.
int number = 2147483647;
long bigNumber = number;

В C# при явно конвертиране на типове (type casting) се изисква използването на оператор за преобразуване на данни (type). Такова конвертиране се използва в случаите, когато по време на конвертирането може на настъпи загуба на информация. Типичен пример е конвертиране на числови данни към тип с по-малка точност или обхват. Ако конвертирането не може да бъде изпълнено без загуба на данни, компилатора на C# автоматично съобщава, че трябва да бъде направено явно. При явното конвертиране изрично се уведомява компилатора, че може да се появи загуба на информация, а самото конвертиране на практика става с поставянето на желания тип в скоби непосредствено преди името или стойността на променливата.

// В този пример се конвертира от тип double в int, програмата
// няма да се компилира, ако не се използва явно конвертиране:
class TypeCasting
{
    static void Main()
    {
        double x = 123.45;
        int y;
        y = (int)x;
        System.Console.WriteLine(y);
    }
}
// Изходът от тази програма ще бъде: 123

В C# също може да се конвертира чрез класът "Convert", чиито методи са "ToString", "ToInt32" и други.

Източници[редактиране | edit source]

  1. CodingUnit Programming Tutorials - C-tutorial Type Casting
  2. Книга “Въведение в програмирането със C#”
  3. MSDN: Casting and Type Conversions (C# Programming Guide)

Външни препратки[редактиране | edit source]