Чому ми повинні згадати тип даних змінної у C

Зазвичай в C ми повинні сказати комп'ютеру тип даних у змінному оголошенні. Наприклад, у наступній програмі я хочу надрукувати суму двох чисел з плаваючою комою X та Y.

#include<stdio.h>
main()
{
  float X=5.2;
  float Y=5.1;
  float Z;
  Z=Y+X;
  printf("%f",Z);

}

Я повинен був сказати компілятору тип змінної X.

• Не може компілятор Xсамостійно визначити тип ?

Так, це можна, якщо я це роблю:

#define X 5.2

Тепер я можу написати свою програму, не повідомляючи компілятору тип X:

#include<stdio.h>
#define X 5.2
main()
{
  float Y=5.1;
  float Z;
  Z=Y+X;
  printf("%f",Z);

}  

Отже, ми бачимо, що мова С має якусь особливість, за допомогою якої вона може визначати тип даних самостійно. У моєму випадку було визначено, що Xце тип float.

• Чому ми мусимо згадувати тип даних, коли ми декларуємо щось головне ()? Чому компілятор не може самостійно визначити тип даних змінної, main()як це робиться в #define.

Ви порівнюєте декларації змінної з #defines, що невірно. З допомогою A #defineви створюєте відображення між ідентифікатором та фрагментом вихідного коду. Потім препроцесор C буквально замінить будь-які виникнення цього ідентифікатора наданим фрагментом. Написання

#define FOO 40 + 2
int foos = FOO + FOO * FOO;

в кінцевому підсумку це те саме, що і для компілятора, як і для написання

int foos = 40 + 2 + 40 + 2 * 40 + 2;

Подумайте про це як про автоматичне копіювання та вставлення.

Також звичайні змінні можна перепризначити, тоді як макрос, створений за #defineдопомогою, не може (хоча ви можете #defineйого повторно ). Вираз FOO = 7буде помилкою компілятора, оскільки ми не можемо призначити "rvalues": 40 + 2 = 7є незаконним.

Отже, навіщо нам взагалі потрібні типи? Деякі мови, мабуть, позбавляються від типів, особливо це часто зустрічається в мовах скриптів Однак вони зазвичай мають щось, що називається "динамічне введення тексту", де змінні не мають фіксованих типів, але мають значення. Хоча це набагато гнучкіше, воно також менш ефективно. C любить продуктивність, тому має дуже просту та ефективну концепцію змінних:

Існує розтяг пам'яті під назвою "стек". Кожна локальна змінна відповідає області в стеку. Тепер питання в тому, скільки байтів має тривати ця область? У C кожен тип має чітко визначений розмір, до якого можна здійснити запит sizeof(type). Компілятору необхідно знати тип кожної змінної, щоб він міг резервувати правильний простір у стеку.

Чому константи, створені з #defineнеобхідністю, не потребують анотації типу? Вони не зберігаються в стеку. Натомість #defineстворює фрагменти вихідного коду для багаторазового використання дещо кориснішим способом, ніж копіювання та вставка. Літерали у вихідному коді, такі як "foo"або 42.87зберігаються компілятором, або вкладені як спеціальні вказівки, або в окремий розділ даних отриманого двійкового файлу.

Однак літерали мають типи. Буквальний рядок - це char *. 42є, intале може також використовуватися для коротших типів (звуження перетворення). 42.8буде a double. Якщо у вас є літерал і ви хочете, щоб він мав інший тип (наприклад, зробити 42.8a floatчи 42an unsigned long int), тоді ви можете використовувати суфікси - літеру після літералу, яка змінює спосіб поводження компілятора з цим літералом. У нашому випадку можна сказати 42.8fчи 42ul.

Деякі мови мають статичну типізацію, як у С, але примітки про тип необов’язкові. Прикладами є ML, Haskell, Scala, C #, C ++ 11 та Go. Як це працює? Магія? Ні, це називається "типовий умовивід". У C # і Go компілятор розглядає праву частину завдання і виводить тип цього. Це досить просто, якщо правий бік є буквальним на зразок 42ul. Тоді очевидно, яким повинен бути тип змінної. В інших мовах також є складніші алгоритми, які враховують спосіб використання змінної. Наприклад, якщо ви це робите x/2, то xце не може бути рядком, але повинно мати деякий числовий тип.

X у другому прикладі ніколи не є поплавком. Він називається макросом, він замінює визначене значення макросу "X" у джерелі значенням. Прочитується стаття на #define знаходиться тут .

У разі поставленого коду перед компіляцією препроцесор змінює код

Z=Y+X;

до

Z=Y+5.2;

і ось що складається.

Це означає, що ви також можете замінити ці значення на код типу

#define X sqrt(Y)

або навіть

#define X Y

Коротка відповідь - типи потреб C через історію / представлення обладнання.

Історія: C був розроблений на початку 1970-х років і призначений як мова для програмування систем. Код ідеально швидкий і найкраще використовує можливості апаратного забезпечення.

Визначення типів під час компіляції було б можливим, але і без того повільний час компіляції збільшився (див . Мультфільм "компіляція" XKCD. Це було застосовано до "привітного світу" принаймні 10 років після публікації C ). Визначення типів під час виконання не відповідало б цілям програмування систем. Виконання часу виконання вимагає додаткової бібліотеки часу виконання. C прийшов задовго до першого ПК. Який мав 256 ОЗУ. Не гігабайти чи мегабайти, а кілобайти.

У вашому прикладі, якщо ви пропустите типи

   X=5.2;
   Y=5.1;

   Z=Y+X;

Тоді компілятор міг із задоволенням розібратися, що X&Y - плаваючі та зробив Z те саме. Насправді сучасний компілятор також розібрався б у тому, що X & Y не потрібні, і просто встановити Z на 10.3.

Припустимо, що обчислення вбудовано у функцію. Записувач функцій, можливо, захоче використати свої знання про обладнання або проблему, що вирішується.

Невже дубль буде доречнішим за поплавок? Займає більше пам’яті та повільніше, але точність результату була б вищою.

Можливо, повернене значення функції може бути int (або довгим), тому що децималі не були важливими, хоча перетворення з float в int не обійшлося без витрат.

Повернене значення також може бути подвійним, гарантуючи, що float + float не переливається.

Усі ці питання здаються безглуздими для переважної більшості кодів, написаних сьогодні, але були життєво важливими, коли вироблявся C.

У C немає висновку типу (це те, що його називають, коли компілятор відгадує тип змінної для вас), оскільки він старий. Він був розроблений на початку 1970-х

У багатьох нових мовах є системи, які дозволяють використовувати змінні, не вказуючи їх тип (ruby, javascript, python тощо)