Chapitre 2 : des classes et des objets #

#pragma once

// @warning: this class is verbose for educational purposes only.
class Point
{
  public:
  
  // ========== BASIC METHODS ==========

  // Without C++ contructors, we would need to use an init method.
  // This is not needed in C++
  // void init(int px, int py)
  // {
  //     m_x = px;
  //     m_y = py;
  // }
  
  // Implicitly inline methods
  void setX(int x) {m_x = x;}
  void setY(int y) {m_y = y;}
  void setXY(int x, int y){m_x = x; m_y = y;}

  // Inline with definition in header (see end of this file) 
  int getX() const;
  int getY() const;

  void translate(int dx, int dy); 

  // ========== CONSTRUCTORS ==========
  // Default constructor
  Point();

  // Constructor
  Point(int x, int y);

  // Copy constructor
  Point(const Point &p);

  // Conversion constructor from int to Point
  explicit Point(int v);

  // ========== DESTRUCTOR ==========
  virtual ~Point(); // virtual: see chapter on polymorphism

  // ========== COPY ASSIGNMENT ==========
  // Just make it default (compiler-generated)
  Point& operator=(const Point &p) = default;

  // ========== CONST METHODS ==========
  void print() const;

  // ========== 'this' POINTER USAGE ==========
  // Demonstrates: using 'this' pointer
  bool isSameObject(const Point &other) const;

  // Demonstrates: '*this' (dereferencing)
  Point getCopy() const;

  // ========== STATIC MEMBERS ==========
  // Do not belong to a specific instance
  static int getCounts();

  // ========== FRIEND FUNCTION ==========
  friend double distance(const Point &p1, const Point &p2);

  // ========== RETURNING A REFERENCE ==========
  // Allows: p.X() = 5;  or  p.X()++;
  // NOTE: This breaks encapsulation (equivalent to making m_x public).
  //       In practice, prefer getX()/setX() for simple attributes.
  int X() const {return m_x;}
  // Cannot be const
  int &X() {return m_x;}
  int Y() const {return m_y;}
  // Cannot be const
  int &Y() {return m_y;}

private:
  // Attributes
  int m_x{0};
  int m_y{0};

  // Shared attribute for all instances
  static int m_counts;
};

inline int Point::getX() const {return m_x;}
inline int Point::getY() const {return m_y;}

// Non-member function
double distance(const Point &p1, const Point &p2);

#include "Point.h"
#include <print>
#include <cmath>

// ========== STATIC MEMBERS INITIALIZATION ==========
int Point::m_counts = 0;

// ========== 1. BASIC METHODS ==========
void Point::translate(int dx, int dy)
{
  m_x += dx;
  m_y += dy;
}

// ========== 2. CONSTRUCTORS ==========
Point::Point() // : m_x(0), m_y(0) -> not needed. See in-class initialization
{
  m_counts++;
  std::println("  ->default ctor (counts={})", m_counts);
}

// member initializer list
Point::Point(int x, int y) : m_x(x), m_y(y)
{
  m_counts++;
  std::println("  ->standard ctor (with initializer list, counts={})", m_counts);
}

Point::Point(int v) : m_x(v), m_y(v)
{
  m_counts++;
  std::println("  ->conversion ctor (counts={})", m_counts);
}

Point::Point(const Point &p) : m_x(p.m_x), m_y(p.m_y)
{
  m_counts++;
  std::println("  ->copy ctor (counts={})", m_counts);
}

// ========== 3. DESTRUCTOR ==========
Point::~Point()
{
  m_counts--;
  std::println("  ~Point() dtor called (counts={})", m_counts);
}

// ========== 4. CONST METHODS ==========
void Point::print() const
{
  // C++23
  std::println("({}, {})", m_x, m_y);
  // Prior to C++23:
  // std::cout << "(" << m_x << "," << m_y << ")" << std::endl;
}

// ========== 5. 'this' POINTER USAGE ==========

bool Point::isSameObject(const Point &otherPoint) const
{  
  return (this == &otherPoint);
}

Point Point::getCopy() const
{
  return *this;
}

// ========== 6. STATIC METHODS ==========
int Point::getCounts()
{
  return m_counts;
}

// ========== 7. FRIEND FUNCTION ==========
double distance(const Point &p1, const Point &p2)
{
  // Friend of Point: can access private members
  int dx = p1.m_x - p2.m_x;
  int dy = p1.m_y - p2.m_y;
  return std::sqrt(dx * dx + dy * dy);
}

#include "Point.h"

#include <print>
#include <vector>

void f1(Point p)
{
  p.print();
}

void f2(const Point &p)
{
  p.print();
}

void f3(Point *p)
{
  p->print();
}

Point f4()
{
  Point p(5, 6);
  p.print();
  return p;
}

void example01_basic()
{
  Point p1;
  p1.print();

  p1.translate(10, 10);
  p1.print();
}

void example02_conversion()
{
  // Explicitly calls CTor
  Point p1 = Point(4);
  p1.print();
  // GCC: error: conversion from 'int' to non-scalar type 'Point' requested
  // Point p2 = 4;
}

void example03_constructors()
{
  Point p1 = Point();
  p1.print();
  p1.setXY(100, 200);
  p1.print();

  Point p2(1, 2);
  p2.print();
  Point p3 = Point(1, 2);
  p3.print();

  Point p4(p1);
  p4.print();

  Point p5 = p1;
  p5.print();

  Point p6(10);
  p6.print();

  // GCC: error: conversion from 'int' to non-scalar type 'Point' requested
  // Point p7 = 11;

  // GCC: error: no match for 'operator=' (operand types are 'Point' and 'int')
  // Point p8;
  // p8 = 4;

  Point *pP1 = new Point();
  pP1->setXY(150, 250);
  pP1->print();
  delete pP1;
  pP1 = nullptr;
}

void example04_copyConstructor()
{
  Point p1(3, 4);

  Point p4(p1);
  p4.print();

  Point p5 = Point(p1);
  p5.print();

  f1(p4);
  f2(p4);
  f3(&p4);
  Point p6 = f4();
}

void example05_destructor()
{
  {
    Point p1(1, 1);
    Point pn[4];
  }

  auto ptrP = new Point(2, 3);
  ptrP->setXY(150, 250);
  ptrP->print();
  delete ptrP;
  ptrP = nullptr;

  auto ptrTabPoint = new Point[5];
  delete[] ptrTabPoint;
  ptrTabPoint = nullptr;
}

void example06_this()
{
  Point pt(5, 7);
  Point p2(pt);
  Point &refPt = pt;
  Point *ptrPt = &pt;
  Point clone = pt.getCopy();

  pt.print();
  p2.print();
  refPt.print();
  ptrPt->print();
  clone.print();

  std::println("pt.isSameObject(p2): {}", pt.isSameObject(p2));
  std::println("pt.isSameObject(refPt): {}", pt.isSameObject(refPt));
  std::println("pt.isSameObject(*ptrPt): {}", pt.isSameObject(*ptrPt));
  std::println("pt.isSameObject(clone): {}", pt.isSameObject(clone));
}

void example07_static()
{
  std::println("Point::getCounts() = {}", Point::getCounts());

  Point p1(2, 3);
  Point p2(4, 5);
  // Both return the same value: counts is shared by all instances
  // Works, but calling a static method on an instance is misleading.
  // Prefer: Point::getCounts()
  std::println("p1.getCounts() = {}", p1.getCounts());
  std::println("p2.getCounts() = {}", p2.getCounts());

  std::println("Point::getCounts() = {}", Point::getCounts());
}

void example08_friend()
{
  Point p1(7, 9);
  p1.print();

  Point p2(3, 4);
  double d = distance(p1, p2);
  std::println("distance(p1, p2) = {}", d);
}

void example09_returnRef()
{
  // X() returns a reference: allows direct modification
  // Convenient, but use with care (see header comment)
  Point p1(1, 1);
  p1.X()++;
  p1.Y() += 10;
  p1.print();
}

void example10_constGet()
{
  // p1 cannot be changed afterwards
  const Point p1(1, 1);
  // GCC: error: passing 'const Point' as 'this' argument discards qualifiers
  // p1.setX(10);
  p1.getX();
}

void example11_pointArray()
{
  // Use default CTor
  Point p3[10];
  // Use Point(int, int), then use default CTor
  Point p4[4] = {Point(5, 3)};

  auto *p5 = new Point(6, 3);
  delete p5;
  p5 = nullptr;

  auto *p6 = new Point[10];
  for (int i = 0; i < 10; i++)
  {
    p6[i] = Point(2, 3);
  }
  delete[] p6;
  p6 = nullptr;

  std::vector<Point> v(10, Point(2, 3));
}

int main()
{
  example01_basic();
  example02_conversion();
  example03_constructors();
  example04_copyConstructor();
  example05_destructor();
  example06_this();
  example07_static();
  example08_friend();
  example09_returnRef();
  example10_constGet();
  example11_pointArray();

  return 0;
}

#pragma once

// GCC: use compiler flag -Wshadow to get shadowing warnings
class A
{
public:
  A() = default;
  // GCC warning: declaration of 'value' shadows a member of 'A'
  explicit A(int value) : value(value) {}
  // Expressions in initializer list are ok
  A(int value1, int value2) : value(add(value1, value2)) {}
  // Members are initialized in the order of their declaration!!!
  // -> value = 10, then angle = 20
  // GCC warning: 'A::angle' will be initialized after
  A(int otherValue, [[maybe_unused]] double otherAngle) : angle(value + 10),
                                                          value(otherValue) {}
  // No copy allowed
  A(const A &other) = delete;
  int add(int a, int b) const { return a + b; }

  int getValue() const { return value; }
  double getAngle() const { return angle; }

private:
  int value{0};
  double angle{0.0};
};

#include "A.h"

#include <print>

int main()
{
  A a1; // default constructor
  std::println("a1: value={}, angle={}", a1.getValue(), a1.getAngle());
  A a2(1); // constructor with one parameter
  std::println("a2: value={}, angle={}", a2.getValue(), a2.getAngle());
  A a3(1, 2); // constructor with two parameters
  std::println("a3: value={}, angle={}", a3.getValue(), a3.getAngle());
  A a4(1, 2.0);
  std::println("a4: value={}, angle={}", a4.getValue(), a4.getAngle());
  // GCC: error: use of deleted function 'A::A(const A&)'
  // auto a5 = a4;

  return 0;
}