Roman

class Point
{
    double x_coord;
    double y_coord;
  public:
    Point(double x = {}, double y = {}) : x_coord{x}, y_coord{y}
    {
    }
};

class Square
{
    Point* center_pt;
    double size;
  public:
    Square(double x = {}, double y = {}, double sz = {1}) 
     : center_pt{new Point(x / sz, y / sz)}, size{sz}
    {
    }
    ~Square(){ delete center_pt; }
};

int main()
{
  Square sq(10, 10, 2);
  Square sq2();
}

void swap(int& a, int& b)
{
  int c = a;
  a = b;
  b = c;
}

только символы '0', '1', '2', '3', '4', '5','6', '7', '8', '9', 'A, 'B', 'C', 'D', 'E', 'F'.

//...
struct hex_str_traits
{
  static bool is_hex_chars(const char* s)
  {
    auto size{ strlen(s) };
    for (auto idx{ 0 }; idx < size; ++idx)
    {
      if (!in_range(s[idx], '0', '9') && !in_range(s[idx], 'A', 'F'))
        return false;
    }
    return true;
  }
  static bool in_range(const int& value, const int& a, const int& b)
  {
    return a <= value && value <= b;
  }
};
//...

class hex_string : public String
{
//...
public:
  hex_string(const char* s);
//...
};
//...
hex_string::hex_string(const char* s) 
  : String( (hex_str_traits::is_hex_chars(s) ? s : "") )
{
}
//...

#include<iostream>
#include<vector>
using namespace std;

template<typename T>
class Matrix
{
  size_t cols;
  size_t rows;
  vector<vector<T>> m_matrix;
public:
  Matrix(size_t c, size_t r) : cols{c}, rows{r}, m_matrix{}
  {
    m_matrix.reserve(cols);
    for(auto i{0}; i < cols; ++i)
    {
      m_matrix.emplace_back(vector<T>(rows));
    }
  }
  auto begin()
  {
    return m_matrix.begin();
  }
  auto end()
  {
    return m_matrix.end();
  }
  vector<T>& operator[](size_t i)
  {
    return m_matrix[i];
  }
//...
};

int main()
{
  Matrix<int> m(10,10);

  m[5][5] = 5;

  for(auto& c : m)
  {
    for(auto& e : c)
    {
      cout << e << ' ';
    }
    cout << endl;
  }
    return 0;
}

0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 5 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0

#include <iostream>
#include <string>
#include <vector>
#include <fstream>

using std::ofstream;
using std::vector;
using std::string;
using std::cout;
using std::cin;
using std::endl;

class Sport
{
  vector<Sport> Sp;
  char     team;
  double   bal;
  unsigned mesto;
  string   name;
public:
  Sport(string   _name  = {}, char _team = {}, double _bal = {},
        unsigned _mesto = {}, vector<Sport> sp = {})
      : name {_name}, team{_team}, bal{_bal},
        mesto{_mesto},  Sp{sp} {}

private:
  friend ofstream& operator<<(ofstream& ofs, Sport& sp);
};

ofstream& operator<<(ofstream& ofs, Sport& sp)
{
  ofs << sp.name  << ' ';
  ofs << sp.team  << ' ';
  ofs << sp.mesto << ' ';
  ofs << sp.bal   << ' ';
  ofs << endl;
  for(auto& p : sp.Sp)
  {
    ofs << p;
  }
  return ofs;
}

void writeSportsTo(const char* filename, Sport& sp)
{
  ofstream of(filename);
  if(of)
  {
    of << sp;
    of.close();
  }
}

int main()
{
    constexpr char* filename = "C:\\sports.txt";
    Sport sp;
    writeSportsTo(filename, sp);
    return 0;
}

#pragma once
#include <iostream>

template<typename T>
class TypeSize
{
public:
  TypeSize(T v) : value{ v } {};
  ~TypeSize() {};
  void dataTypeSize();
protected:
  T value;
};

template<typename T>
void TypeSize<T>::dataTypeSize()
{
  std::cout << "size: " << sizeof(value) << std::endl;
}

#pragma once
#include <typeinfo> // std::typeid()
#include "TypeSize.h"

template<typename T>
class TypeInfo : public TypeSize<T>
{
public:
  TypeInfo(T v) : TypeSize<T>(v) {};
  ~TypeInfo() {};
  void showTypeInfo();
};

template<typename T>
void TypeInfo<T>::showTypeInfo()
{
  std::cout << "type: " << typeid(this->value).name() << std::endl;
}

#include "TypeInfo.h"

int main()
{
  int a{ 5 };
  TypeInfo<int> infInt(a);
  infInt.dataTypeSize();
  infInt.showTypeInfo();
  std::getchar();
}

struct OLS
{
  int RoomsCount;
  int floor;
  float square;
  OLS *ptr;
  friend bool operator==(OLS& a, OLS& b);
};

typedef OLS* pOLS;

bool operator==(OLS& a, OLS& b)
{
    return (a.RoomsCount == b.RoomsCount) &&
           (a.floor == b.floor) &&
           (a.square != b.square);
}

void CompAndFind(pOLS& str) 
{
  if(!str) return;// nullptr
  pOLS p = str;
  while(p->ptr)
  {
      if(*p == *(p->ptr))
      {
          show(p);
      }
      p = p->ptr;
  }
}