Mercury13

#include <iostream>
#include <memory>
#include <vector>

class Base{
public:
    // Нужен виртуальный деструктор, ведь мы будем уничтожать детей
    // через родительский ук-ль. Да и dynamic_cast требует RTTI,
    // а значит, хоть одного виртуального.
    virtual ~Base() = default;
};

class Exp: public Base
{
int i=0;
public:
       int Get() const {  return i; }
       void Set(const int &num) { i=num; }
};

std::vector<std::shared_ptr<Base>> MyStack;
Base &GetRef() { return **MyStack.begin();  }

int main() {
    std::shared_ptr<Exp> a = std::make_shared<Exp>();
    a->Set(4);
    MyStack.push_back(a);
    int res=dynamic_cast<Exp&>(GetRef()).Get(); // Теперь работает
    std::cout << res << std::endl;;
}

#include <iostream>
#include <conio.h>

int main()
{
  setlocale(LC_ALL, "Russian");
  const size_t SIZE = 3000000000ul;
  char* ptr = NULL;
  try
  {
    ptr = new char[SIZE];
    std::cout << "Память используется без сбоев.\n";
  }
  catch (std::bad_alloc&)
  {
    std::cout << "Исключение bad_alloc: невозможно разместить данные в памяти.\n";
  }
  delete[] ptr;
  getch();
  return 0;
}

void parseCommaList(
        const char *aStart,   // указатель на начало
        const char *aEnd,    // указатель на символ за концом
        char aComma,        // символ-разделитель
        bool aSkipEmpty,   // true, если пустые подстроки пропускать
        ProcParseCommaList aCallback,   // функция-нагрузка
        void *aData)   // этот параметр нужен, чтобы передавать какие хочешь данные в функцию-нагрузку, удаляй его смело!
{
    str::trim(aStart, aEnd);    // моя функция; пододвигает aStart вперёд и aEnd назад, убирая пробелы.
                                // Если удаление пробелов не нужно — удаляй! Если нужно — пиши сам.
    if (aStart == aEnd) return;
    const char *sstart = aStart;
    for (const char *p = aStart; p != aEnd; ++p)
    {
        if (*p != aComma) continue;
        const char *send = p;
        str::trim(sstart, send);   // то же самое, можно убрать
        if (p != sstart || !aSkipEmpty)
            aCallback(sstart, send, aData);    // замени на боевую нагрузку
        sstart = p + 1;
    }
    str::trim(sstart, aEnd);   // то же самое, можно убрать
    if (sstart != aEnd || !aSkipEmpty)
        aCallback(sstart, aEnd, aData);    // замени на боевую нагрузку
}

inline void parseCommaList(
        const std::string &aIn,
        char aComma,
        bool aSkipEmpty,
        ProcParseCommaList aCallback,
        void *aData)
{
    parseCommaList(aIn.data(), aIn.data() + aIn.length(), aComma, aSkipEmpty,
            aCallback, aData);
}

class AddItem : public QWidget
{
public:
  AddItem(QWidget* aParent, QList<Institution>& aInstitutions)
      : QWidget(aParent), institutions(aInstitutions) {}
private:
  QList<Institution>& institutions;
};

class AddItem : public QDialog
{
public:
  int exec(QList<Institution>& aInstitutions);
private:
  QList<Institution> institutions;
};

int AddItem::exec(QList<Institution>& aInstitutions)
{
  institutions = aInstitutions;
  int r = QDialog::exec();
  if (r) {
     aInstitutions = std::move(institutions);
  }
  return r;
}

[r']   ( 1 0 0 shiftx )   [r]
[s'] = ( 0 1 0 shifty ) · [s]
[t']   ( 0 0 1 shiftz )   [t]
[d']   ( 0 0 0 1      )   [d]

QModelIndex EditableTable::moveCursor(
        CursorAction cursorAction, Qt::KeyboardModifiers modifiers)
{
    switch (cursorAction) {
    case QAbstractItemView::MoveNext:
    case QAbstractItemView::MovePrevious:
        return QModelIndex();
        break;
    default:
        return Super::moveCursor(cursorAction, modifiers);
    }
}

class Entity
{
public:
  virtual ~Entity() {}    // для корректной работы динамических структур данных 
                          // наподобие менеджеров уровней; в нашем примере не нужно;
                          // в реальной игре потребуется
}

class Player : public Entity
{
public:
   bool isDead;
}

int main()
{
   Player player;
   player.isDead = true;
   return 0;
}

Player& somePlayer = dynamic_cast<Player&>(someEntity);

class Player
{
public:
   Entity entity;
   bool isDead;
}

struct PlayerInfo
{
    bool isDead;
}

std::map<const Entity*, PlayerInfo> playerInfo;

typedef std::string PlayerId;
std::map<PlayerId, PlayerInfo> playerInfo;