Переменные разных типов

int, float, char, bool, byte и long — что помещается в каждый тип. int a = 3.45 хранит 3: дробная часть не округляется, а отбрасывается. float c = 7 / 2 даёт 3.00, потому что делились целые, а byte после 255 начинает счёт с нуля. Результат — в мониторе порта.

Программа

// Переменные разных типов — что в какую «коробку» помещается.
//
// Переменная — это коробка с именем, а ТИП говорит, что в неё можно положить:
// целое число, дробное, букву или «да/нет». Положили не то — плата не
// ругается, а молча переделывает значение под коробку. Что из этого выходит,
// смотрите в мониторе порта: в каждой строке — переменная и то, что в ней
// оказалось на самом деле.
//
// Всё печатается один раз, в setup(). Чтобы посмотреть снова, нажмите ▶ ещё раз.
// А чтобы пройти программу по шагам, нажмите ›| вместо ▶: она встанет на первой
// строке, и каждое следующее ›| выполнит одну строку — видно, после какой
// появляется очередная строчка в мониторе порта.

void setup() {
  Serial.begin(9600);

  // ── Целые и дробные ──
  // int хранит только целые. Дробную часть он не округляет, а отбрасывает:
  // и 3.45, и 3.99 превращаются в 3.
  int a = 3.45;
  Serial.print("int   a = 3.45    : ");
  Serial.println(a);             // 3

  // float хранит дробные. Второй аргумент println — сколько знаков после
  // запятой печатать.
  float b = 3.45;
  Serial.print("float b = 3.45    : ");
  Serial.println(b, 2);          // 3.45

  // Ловушка: 7 / 2 — деление ЦЕЛЫХ. Остаток выброшен ещё до того, как
  // результат попал во float, и в коробку приезжает уже тройка.
  float c = 7 / 2;
  Serial.print("float c = 7 / 2   : ");
  Serial.println(c, 2);          // 3.00

  // Хватит одного дробного числа в выражении — и деление становится дробным.
  float d = 7 / 2.0;
  Serial.print("float d = 7 / 2.0 : ");
  Serial.println(d, 2);          // 3.50

  // ── Символ и «да/нет» ──
  // char — один символ. Внутри это число, код буквы, поэтому к нему можно
  // прибавлять: следующая за 'A' буква — 'B'.
  char e = 'A';
  char f = e + 1;
  Serial.print("char  e = 'A'     : ");
  Serial.println(e);             // A
  Serial.print("char  f = e + 1   : ");
  Serial.println(f);             // B
  Serial.print("(int) e           : ");
  Serial.println((int)e);        // 65 — код буквы A

  // bool — «да» или «нет». В мониторе порта «да» — это 1, «нет» — 0.
  bool g = 5 > 3;
  Serial.print("bool  g = 5 > 3   : ");
  Serial.println(g);             // 1

  // ── У каждой коробки есть предел ──
  // byte — числа от 0 до 255. После 255 счёт начинается заново, с нуля.
  byte h = 255;
  h = h + 1;
  Serial.print("byte  h = 255 + 1 : ");
  Serial.println(h);             // 0

  // int на Arduino UNO занимает 2 байта: от -32768 до 32767. Перешагнули
  // край — число оказывается на другом конце. Это ошибка программы, а не
  // приём, но встречается постоянно: счётчик в int однажды «переворачивается».
  int i = 32767;
  i = i + 1;
  Serial.print("int   i = 32767+1 : ");
  Serial.println(i);             // -32768

  // long — 4 байта, пределы больше двух миллиардов. Там то же сложение честное.
  long k = 32767;
  k = k + 1;
  Serial.print("long  k = 32767+1 : ");
  Serial.println(k);             // 32768

  // Сколько байт занимает каждый тип, можно спросить у самой платы.
  Serial.print("sizeof(int)       : ");
  Serial.println(sizeof(int));   // 2
  Serial.print("sizeof(long)      : ");
  Serial.println(sizeof(long));  // 4
  Serial.print("sizeof(float)     : ");
  Serial.println(sizeof(float)); // 4
}

void loop() {
}

Схема примера появится, когда загрузится страница: её собирает и считает движок цепей.

← Ко всем примерам