// gfx/geometry/point.h

class GFX_EXPORT Point {
 public:
  constexpr Point() : x_(0), y_(0) {}
  constexpr Point(int x, int y) : x_(x), y_(y) {}
  . . .

// gfx/geometry/size.h

class GFX_EXPORT Size {
 public:
  constexpr Size() : width_(0), height_(0) {}
  constexpr Size(int width, int height)
  . . .

// gfx/geometry/rect.h

class GFX_EXPORT Rect {
 public:
  constexpr Rect() = default;
  constexpr Rect(int width, int height) : size_(width, height) {}
  constexpr Rect(int x, int y, int width, int height)
  . . .

// gfx/geometry/insets.h

class GFX_EXPORT Insets {
 public:
  constexpr Insets() : top_(0), left_(0), bottom_(0), right_(0) {}
  constexpr explicit Insets(int all)
      : top_(all), left_(all), bottom_(all), right_(all) {}
  constexpr Insets(int vertical, int horizontal)
      : top_(vertical),
        left_(horizontal),
        bottom_(vertical),
        right_(horizontal) {}
  constexpr Insets(int top, int left, int bottom, int right)
      : top_(top), left_(left), bottom_(bottom), right_(right) {}
  . . .

К>а вместо width/height — vertical/horizontal, соответственно

Insets(int vertical, int horizontal)
: top_(vertical),
left_(horizontal),
bottom_(vertical),
right_(horizontal) {}

D>Николай, не очень понял

 constexpr Insets(int top, int left, int bottom, int right)

К>Уважаемые знатоки! Как вы думаете, почему я обратил на это внимание?

//
// An insets represents the borders of a container (the space the container must
// leave at each of its edges).
//

class Rect {
  . . .
  // Shrink the rectangle by the given insets.
  void Inset(const Insets& insets);

  // Shrink the rectangle by the specified amount on each side.
  void Inset(int left, int top, int right, int bottom);

  // Move the rectangle by a horizontal and vertical distance.
  void Offset(int horizontal, int vertical);
  void Offset(const Vector2d& distance) { Offset(distance.x(), distance.y()); }
  void operator+=(const Vector2d& offset);
  void operator-=(const Vector2d& offset);

  Insets InsetsFrom(const Rect& inner) const;
  . . .

constexpr Point() : x_(0), y_(0) {}  - нафиг constexpr. что он дает?
  constexpr Point(int x, int y) : x_(x), y_(y) {} - зачем два конструктора, когда одного достаточно с дефолтными параметрами?

 constexpr int x() const { return x_; } - убрать нафиг эти методы, сделать члены x и y публичными
  constexpr int y() const { return y_; }

  void set_x(int x) { x_ = x; } - наркомания!
  void set_y(int y) { y_ = y; }
  void SetPoint(int x, int y) { - тяжелая наркомания! зачем нужен метод копирующий реализацию конструктора? почему не p = Point(10, 20), зачем вообще нужен этот set?
    x_ = x;
    y_ = y;
  }

почему паскалевское именование в С++ проекте?

 void SetToMin(const Point& other);  - непонятная фигня. почему это метод класса Point?

 std::string ToString() const; - почему это метод класса а не статич ф-ия?

__>constexpr Point() : x_(0), y_(0) {}  - нафиг constexpr. что он дает?

__>  constexpr Point(int x, int y) : x_(x), y_(y) {} - зачем два конструктора, когда одного достаточно с дефолтными параметрами?

__> constexpr int x() const { return x_; } - убрать нафиг эти методы, сделать члены x и y публичными
__>  constexpr int y() const { return y_; }

__> void SetToMin(const Point& other);  - непонятная фигня. почему это метод класса Point?

struct S
{
    int x = 10;
};

__>точнее даже так — __kot2 это нормальный идентификатор в С++?

Each name that contains a double underscore __ or begins with an underscore followed by an uppercase
letter (2.12) is reserved to the implementation for any use.

__>struct S
__>{
__>    int x = 10;
__>};
__>

struct Point
{
    int x = 0;
    int y = 0;

    constexpr Point() = default;
    constexpr Point(int x, int y) : x(x), y(y) {}
...
};

Point::Point() : Point(0, 0) {}

// .h

class Foo {
 public:
  Foo(const Foo&); // = default
  . . . .
 private:
  int x_, y_, z_;
};

// .cc
Foo::Foo(const Foo&) = default;

К>// .h

К>class Foo {
К> public:
К>  Foo(const Foo&); // = default
К>  . . . .
К> private:
К>  int x_, y_, z_;
К>};

К>// .cc
К>Foo::Foo(const Foo&) = default;
К>

// .hpp
template<typename T>
struct PointT
{
    T x = {};
    T y = {};

    PointT();
    PointT(T x, T y);
}; 

using Point = PointT<int>;
using PointF = PointT<float>;

// declare explicit instantiation
extern template PointT<int>;
extern template PointT<float>;

// .cpp
template<typename T>
struct PointT<T>::PointT() = default;

template<typename T>
struct PointT<T>::PointT(T x, T y) : x(x), y(y) {}

// define explicit instantiation
template PointT<int>;
template PointT<float>;

background-size: 300px 100px;       /* width->300, height->100 */

/* but! */

padding: 1.6em 20px;        /* top and bottom (vertical) 1.6em, left and right (horizontal) 20px margin */
padding: 1em 3px 30px 5px;  /*  top    1em  padding  */
                            /*  right  3px  padding  */
                            /*  bottom 30px padding  */
                            /*  left   5px  padding  */