1.1.5.1 Numerical Conversion

• Assigning a value to a type with a greater range usually poses no problem. If shorter range or different type, maybe there are some problems.
• Assigned to a bool, zero will convert to false, and nonzero will convert to true.
• When conversion, maybe lost precision(double -> float, long long ->float) loss fragment(float -> i) or Undefine (int i = 666, then char c = i;) Detail example can be seen in my evernote bookmark.
  int i, float f; 
  i=f; 
  //1) fragment will be lost,  f= 3.99, i will be 3 (not rounding) 
  //2) If f is too big.  undefined behave 
   
  f = i; 
  // 1) will lost precision if i is big.
• A implicit conversion will happened when you call a function.(Just like you use assignment operator=). Below they all compile successfully. You can use =delete keyword to resolve this questions.
  bool isLucky(int number); 
   
  isLucky(’a’) //i = ’a’ , promotion 
  isLucky(false) //i = false, promotion 
  isLucky(1.2f) //i = f , standard conversion.
• Compile with -Wconversion flag, it doesn’t included in -Wall in g++; It just give warning when standard conversion happen
  isLucky(’a’) //promotion, ______NO warning 
  isLucky(false) //promotion, ______NO warning 
  isLucky(1.2f) //standard conversion, Warning
• In C++, introduce brace initialization {}, It will not allow narrowing happen. But in g++, it just show a -Wnarrowing message, Anyway, I think that It’s helpful.
  int x = 66; 
  char c1 = {x}; //ok 
   
  int x = 666; 
  char c2 = {x};  // not allowed;
• When an operation involves two types, the smaller is converted to the larger. Adding an int to a float, int is converted to float type. (You have to do it, because two types have the different inside representations)
• In an expression, C++ makes two kinds of automatic conversion. 1) Some type are automatically converted whenever they occur. 2) Some type are converted when they are combined with other types in an expression.
• C++ converts bool, char, unsighed char, signed char and short to int. Because int type is generally chosen to be the computer’s most natural type. It does calculations faster for that type. It’s called integer promotions.
• unsigned short convert to int if short is shorter than int, if they have the same size. unsigned short convert to unsigned int. So no data loss in promoting.
  char c1, c2, c //s1 and s2 convert to int first. 
  c = c1+c2;  // then change int result back to short. 
  /*  LLVM IR code below 
    store i8 97, i8* %c1, align 1 
    store i8 2, i8* %c2, align 1 
    %0 = load i8, i8* %c1, align 1 
    %conv = ________sext i8 %0 to i32 
    %1 = load i8, i8* %c2, align 1 
    %conv1 = sext i8 %1 to i32 
    %add = add nsw i32 %conv, %conv1 
    %conv2 = ________trunc i32 %add to i8 
  */ 
   
  i+f // i will promoted to f and value keep the same. 
   
  float f1, f2, f 
  f = f1+f2 // whether f1 change to double debpends on compiler 
  //clang++ has fadd in LLVM IR, so it doesn’t change f to double.