Mercury13

std::string commandLine = console.getSomeCommandLine();
Command command;
std::string error;
if (!command.parse(commandLine, error)) {
  console.err().writeln(error);
  return;
}
Program* program = system.findProgram(command.programName);
if (!program) {
  console.err().writeln("Bad command or file name");
  return;
}
Console redirectedConsole = console.redirectStreams(command);
program->exec(redirectedConsole, system, command.getArguments());

const std::vector<std::string>& getArguments() const;
const std::vector<std::string>& getOptions() const;

///// Защита от повторного включения
#ifndef Unit1H
#define Unit1H

///// Хедеры VCL. Причём всё это сделано так, чтобы упростить написание ценой удлинения
///// компиляции. Более громоздкий, но и более удачный вариант.
///// В H:
/////   namespace Controls { class TLabel; }
/////   using namespace Controls;
///// В CPP:
/////   #include <Controls.hpp>
///// Вот таким образом можно (было) избавиться от каскадного подключения
///// хедера Controls. А то каждый, кто использует главной форму,
///// автоматически подключает эти хедеры.
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
///// Только от Forms.hpp избавиться таким макаром нельзя:
///// мы наследуемся от TForm.
#include <Forms.hpp>

///// Класс формы. Все формы наследуются от TForm.
class TForm1 : public TForm
{
   ///// Особое право доступа Borland, для совместимости с Delphi.
   ///// Поля и свойства published не просто public, но включаются
   ///// в структуру рефлексии (aka reflection или introspection)
   ///// и программа о них знает при выполнении.
   ///// Применительно к формам — published-поля доступны
   ///// загрузчику.
__published: // IDE-managed Components
   ///// Компоненты, которые мы установили на форме редактором.
TLabel *Label1;
TButton *Button1;
   ///// События, которые мы прописали в редакторе.
   ///// __fastcall — модель вызова, аналогичная Delphi.
   ///// Именно такая модель вызова принята в обработчиках
   ///// событий.
void __fastcall Button1Click(TObject *Sender);
   ///// Пользователь пока не прописал никаких своих
   ///// полей и функций.
private: // User declarations
public: // User declarations
   ///// Конструктор. Раз уж у формы нетривиальный конструктор —
   ///// по правилам Си++ его надо повторить в подклассе.
   ///// Снова-таки, модель вызова __fastcall: в формах Delphi
   ///// используются т.н. виртуальные конструкторы, 
   ///// когда по имени класса можно создать объект этого класса.
   ///// Фабричный метод, только немного лучше.
   ///// Но это значит: у всех подчинённых классов
   ///// должен быть один и тот же набор параметров
   ///// и модель вызова.
__fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
///// Как известно, переменная объявляется один раз.
///// Поскольку хедер может подключаться к огромному числу CPP,
///// её объявляют как extern (она есть, но в другом месте).
///// Макрос PACKAGE раскрывается в __declspec(package),
///// чтобы эту штуку можно было собрать как пакет.
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

class Stream {
public:
  virtual void write(size_t length, const void* data) = 0;

  // пишет в поток word в машинном порядке байтов
  void writeW(uint16_t data) {
    write(2, &data);
  }
};

class ErpConnector {
public:
  // 80% модулей не могут экспортировать данные в систему управления
  //   предприятием — напишем базовую реализацию.
  virtual bool canExportData() const { return false; }
  virtual void exportData() const {}
};

void im::DateGrouper::toFirstDateOfPeriod(dt::Date& aDate, int aStart) const
{
    aDate = toDate(toInt(aDate, aStart), aStart);
}

void im::MonthGrouper::toFirstDateOfPeriod(dt::Date& aDate, int aStart) const
{
    if (aDate.day < aStart)
        aDate.addMonthsMechanical(-1);  // механически вычесть 1 месяц; дата может стать неверной.
    aDate.day = aStart;
    aDate.fixupTo1();    // неверную дату привести к 1-му числу следующего месяца
}

someObj.UserData := TObject(true);
someBool := boolean(someObj.UserData);

someObj.UserData := dummyObject;
someBool := (someObj.UserData <> nil);

initialization
  dummyObject := TObject.Create;
finalization
  dummyObject.Free;
end.

TBoolObject = class
public
  Value : boolean;
  // конструкторы опущу, деструктор не нужен
end.

someObj.UserData := TBoolObject(true);
someBool := (someObj.UserData as TBoolObject).Value;

TObjBool = record
case integer of
0 : ( asObj : TObject );
1 : ( asBool : boolean );
end;

// HEADER
class WebMaster {
public:
    WebMaster();
    bool connect_open();
private:
    static EthernetClient client;
}

// CPP
EthernetClient WebMaster::client;

class WebMaster {
public:
    WebMaster();
    bool connect_open();
private:
    EthernetClient client;
}

// HEADER
class WebMaster {
public:
    WebMaster(EthernetClient& aClient);
    bool connect_open();
private:
    EthernetClient& client;
}

// CPP
WebMaster::WebMaster(EthernetClient& aClient) : client(aClient) {}

...
EthernetClient client;
WebMaster webmaster(client);

class Edge : public EdgeBase
{
public:
  Edge (Point* firstPoint, Point* secondPoint) { init(firstPoint, secondPoint); }
  Edge () { init(NULL, NULL); }
  void init (Point* firstPoint, Point* secondPoint)
  {
    this->firstPoint = firstPoint;
    this->secondPoint = secondPoint;
  }
private:
  Point* firstPoint;
  Point* secondPoint;
};

#include <iostream>

class ImmutableInt
{
public:
    explicit ImmutableInt(int x) : fData(x) {}
    int data() const { return fData; }
private:
    int fData;
};

template <class Payload>
class ListItem
{
public:
    Payload payload;
    ListItem* next;

    ListItem() : next(NULL) {}
    ListItem(const Payload& x) : payload(x), next(NULL) {}
};

// Так писать нельзя — эта конструкция расшаблонивает все функции,
// а конструктора по умолчанию как не было, так и нет!
//template class ListItem<ImmutableInt>;

int main()
{
    ListItem<ImmutableInt> li(ImmutableInt(42));
    std::cout << li.payload.data() << std::endl;
    return 0;
}

#include <iostream>

class ImmutableInt
{
public:
    explicit ImmutableInt(int x) : fData(x) {}
    int data() const { return fData; }
private:
    int fData;
};

template <class Payload>
class ListItem
{
public:
    Payload payload;
    ListItem* next = nullptr;

    template<class... Args>ListItem(Args... args) : payload(args...) {}
};

int main()
{
    ListItem<ImmutableInt> li(42);
    std::cout << li.payload.data() << std::endl;
    return 0;
}

template<typename type_t>
struct item
{
  item* next;
  type_t data;
};