Why does the compiler warn me that it narrows from `int` to` uint8`?

Question

I checked again and aigain, I am sure that I did not use uint8for int implicitly in my code, neither forward nor backward.

// main.cpp
#include <iostream>
using std::cout, std::endl;

using uint8 = unsigned char;

struct Vector {
  uint8 x, y, z;

  Vector operator+(const Vector& v) const {
    return Vector{this->x + v.x, this->y + v.y, this->z + v.z};
  };
  void operator+=(const Vector&);
  void operator-(const Vector&) const;
  Vector operator-=(const Vector&);
  Vector operator*(const uint8 scaler) const;
  Vector Corss(const Vector&, const Vector&) const;
  void Corss(const Vector&);
  Vector Dot(const Vector&, const Vector&) const;
  void Dot(const Vector&);
};

std::ostream& operator<<(std::ostream& os, Vector& vec) {
  return os << "(" << (unsigned)vec.x << "," << (unsigned)vec.y << ","
            << (unsigned)vec.z << ")";
}
int main() {
  Vector v1{1, 2, 3};
  Vector v2{1, 1, 1};
  Vector v3 = v1 + v2;
  cout << v1 << endl;
  cout << v2 << endl;
  cout << v3 << endl;
}

line:

$g++ main.cpp -std=c++17 -O0 -g -Wall -Wextra
main.cpp: In member function 'Vector Vector::operator+(const Vector&) const':
main.cpp:10:27: warning: narrowing conversion of '(((int)((const Vector*)this)->Vector::x) + ((int)v.Vector::x))' from 'int' to 'uint8 {aka unsigned char}' inside { } [-Wnarrowing]
     return Vector{this->x + v.x, this->y + v.y, this->z + v.z};
                   ~~~~~~~~^~~~~
main.cpp:10:42: warning: narrowing conversion of '(((int)((const Vector*)this)->Vector::y) + ((int)v.Vector::y))' from 'int' to 'uint8 {aka unsigned char}' inside { } [-Wnarrowing]
     return Vector{this->x + v.x, this->y + v.y, this->z + v.z};
                                  ~~~~~~~~^~~~~
main.cpp:10:57: warning: narrowing conversion of '(((int)((const Vector*)this)->Vector::z) + ((int)v.Vector::z))' from 'int' to 'uint8 {aka unsigned char}' inside { } [-Wnarrowing]
     return Vector{this->x + v.x, this->y + v.y, this->z + v.z};
                                                 ~~~~~~~~^~~~~
$./a.out
(1,2,3)
(1,1,1)
(2,3,4)

Answer 1

Each term in this->x + v.x& c. automatically expands to int, and the type of this expression is int. This is because the arguments +are narrower than int. Then your compiler will give you a warning as you initialize elements Vectorthat are of a narrower type than int.

This is a fact of life in C ++. You get the same effect with something like

auto a = 'a' + 'b';

a- type int.