приведение c ++ к байту (unit8_t) во время вычитания не вызовет недостаточного заполнения, как я ожидал; вывод int16_t; Зачем?

Итак, я понял это:

Ответ очень прост, но понимание этого не является.

Ответ:

(Как это исправить):
Вместо того, чтобы использовать (byte)seconds - tStartиспользовать (byte)((byte)seconds - tStart), Это оно! Задача решена! Все, что вам нужно сделать, это разыграть выход математической операции (в данном случае вычитание) в byte а также, и это исправлено! В противном случае он возвращается как подписанный int, который производит ошибочное поведение.

Итак, почему это происходит?

Ответ:
В C, C ++ и C #, нет математической операции над байтом! По-видимому, функции уровня сборки, необходимые для таких операторов, как +, — и т. Д., Не существуют для байтовых вводов. Вместо этого все байты сначала неявно преобразуются (повышаются) в int перед выполнением операции, затем выполняется математическая операция над Интс, и когда он завершен, он возвращает ИНТ тоже!

Итак, этот код (byte)seconds - tStart неявно приводится (повышается в этом случае) компилятором следующим образом: (int)(byte)seconds - (int)tStart… и возвращает int тоже. Смущает, а? Я конечно так думал!

Вот еще немного чтения по этому вопросу:

(чем больше звездочек *, тем полезнее)

• *****byte + byte = int … почему? <- ОСОБЕННО ПОЛЕЗНЫЙ
• *****Неявные правила преобразования типов в операторах C ++ <- ОСОБЕННО ПОЛЕЗНЫЙ. Этот ответ Вот показывает, когда происходят неявные приведения, и заявляет «Заметка. Минимальный размер операций int, Так short/char повышены до int до того, как операция сделана.«
• *****Поиск в Google «c ++ неявное приведение происходит с сравнениями?»
• https://www.tutorialspoint.com/cprogramming/c_type_casting.htm
• http://www.improgrammer.net/type-casting-c-language/
• Google ищет «неявное приведение c ++»
• http://www.cplusplus.com/doc/tutorial/typecasting/
• http://en.cppreference.com/w/cpp/language/implicit_conversion
• http://en.cppreference.com/w/cpp/language/operator_comparison

Теперь давайте посмотрим на некоторые реальные примеры C ++:

Вот полная программа на C ++, которую вы можете скомпилировать и запустить для проверки выражений, чтобы увидеть, что является возвращаемым типом, и был ли он неявно приведен компилятором к чему-то, что вы не намереваетесь:

#include <iostream>

using namespace std;

//----------------------------------------------------------------
//printTypeAndVal (overloaded function)
//----------------------------------------------------------------
//UNSIGNED:
void printTypeAndVal(uint8_t myVal)
{
cout << "uint8_t = " << (int)myVal << endl; //(int) cast is required to prevent myVal from printing as a char
}
void printTypeAndVal(uint16_t myVal)
{
cout << "uint16_t = " << myVal << endl;
}
void printTypeAndVal(uint32_t myVal)
{
cout << "uint32_t = " << myVal << endl;
}
void printTypeAndVal(uint64_t myVal)
{
cout << "uint64_t = " << myVal << endl;
}
//SIGNED:
void printTypeAndVal(int8_t myVal)
{
cout << "int8_t = " << (int)myVal << endl; //(int) cast is required to prevent myVal from printing as a char
}
void printTypeAndVal(int16_t myVal)
{
cout << "int16_t = " << myVal << endl;
}
void printTypeAndVal(int32_t myVal)
{
cout << "int32_t = " << myVal << endl;
}
void printTypeAndVal(int64_t myVal)
{
cout << "int64_t = " << myVal << endl;
}
//FLOATING TYPES:
void printTypeAndVal(float myVal)
{
cout << "float = " << myVal << endl;
}
void printTypeAndVal(double myVal)
{
cout << "double = " << myVal << endl;
}
void printTypeAndVal(long double myVal)
{
cout << "long double = " << myVal << endl;
}

//----------------------------------------------------------------
//main
//----------------------------------------------------------------
int main()
{
cout << "Begin\n\n";

//Test variables
uint8_t u1 = 0;
uint8_t u2 = 1;

//Test cases:

//for a single byte, explicit cast of the OUTPUT from the mathematical operation is required to get desired *unsigned* output
cout << "uint8_t - uint8_t:" << endl;
printTypeAndVal(u1 - u2); //-1 (bad)
printTypeAndVal((uint8_t)u1 - (uint8_t)u2); //-1 (bad)
printTypeAndVal((uint8_t)(u1 - u2)); //255 (fixed!)
printTypeAndVal((uint8_t)((uint8_t)u1 - (uint8_t)u2)); //255 (fixed!)
cout << endl;

//for unsigned 2-byte types, explicit casting of the OUTPUT is required too to get desired *unsigned* output
cout << "uint16_t - uint16_t:" << endl;
uint16_t u3 = 0;
uint16_t u4 = 1;
printTypeAndVal(u3 - u4); //-1 (bad)
printTypeAndVal((uint16_t)(u3 - u4)); //65535 (fixed!)
cout << endl;

//for larger standard unsigned types, explicit casting of the OUTPUT is ***NOT*** required to get desired *unsigned* output! IN THIS CASE, NO IMPLICIT PROMOTION (CAST) TO A LARGER *SIGNED* TYPE OCCURS.
cout << "unsigned int - unsigned int:" << endl;
unsigned int u5 = 0;
unsigned int u6 = 1;
printTypeAndVal(u5 - u6); //4294967295 (good--no fixing is required)
printTypeAndVal((unsigned int)(u5 - u6)); //4294967295 (good--no fixing was required)
cout << endl;

return 0;
}

Вы также можете запустить эту программу онлайн здесь: http://cpp.sh/6kjgq

Вот выход. Обратите внимание, что оба байта без знака uint8_t - uint8_t регистр и двойной байт без знака uint16_t - uint16_t каждый случай был неявно приведен (повышен) компилятором C ++ к 4-байтному подписанный int32_t (int) тип переменной. Это поведение, которое вы должны заметить. Следовательно, результат этих вычитаний отрицательный, это необычное поведение, которое первоначально смутило меня, так как я ожидал, что вместо этого он опустится до максимального значения переменной без знака (так как мы делаем 0 — 1). Для того, чтобы достичь желаемого нижнего уровня, мне пришлось эксплицитно бросить выходной результат вычитания до желаемого типа без знака, а не только входные. Для unsigned int В этом случае явное приведение результата НЕ требовалось.

Начать

uint8_t — uint8_t:
int32_t = -1
int32_t = -1
uint8_t = 255
uint8_t = 255

uint16_t — uint16_t:
int32_t = -1
uint16_t = 65535

unsigned int — unsigned int:
uint32_t = 4294967295
uint32_t = 4294967295

Вот еще один краткий пример программы, чтобы показать, что один байт без знака (unsigned char) переменные преобразуются в подписанные целые числа (int) при операции.

#include <stdio.h>

int main(int argc, char **argv)
{
unsigned char x = 130;
unsigned char y = 130;
unsigned char z = x + y;

printf("%u\n", x + y); // Prints 260.
printf("%u\n", z);     // Prints 4.
}

Выход:

260
4

Проверьте здесь: http://cpp.sh/84eo