Евгений Шатунов

class a final
{
private:
	class ex
	{
		int f = 0;
	};
	
	static void foo() { std::cout << 'f' << std::endl; };
	
public:
	class F
	{
	public:
		F() { foo(); };
		
	private:
		ex m_exes[4];
	};
};

state ? (cout << b / a << endl, exit(0)) : state = (a == 0) && (b == 0);

void display()
{
   glClear( GL_COLOR_BUFFER_BIT );
   glBegin( GL_LINE_LOOP );

   for( size_t index = 0; index < vertices.size(); ++index )
   {
      const Vertex& vertex = vertices[ ( index * 3 ) % vertices.size() ];
      glVertex2i( vertex.x, vertex.y );
   }

   glEnd();
   glFlush(); 
}

#include <iostream>
#include <functional>

class Enemy final
{
public:
	std::function<void()> update = []() {};
};

int main( int argc, char* argv[] )
{
	Enemy enemy;
	enemy.update = []() { std::cout << "Hello"; };

	enemy.update();
	return 0;
}

Foo bar = {...};
Foo bar{...};

s = loc::get("key");    // ambiguous overload for op=

template <typename T1>
void out_array(const T1* array, size_t arraySize)

template < typename TElementType, size_t LENGTH >
void out_array( const TElementType array[ LENGTH ] )

char array2[n] = { '2','1','4','5','3','-3','-1','-2','-4','-5' };

int array3[n];
std::transform(
    std::begin( array2 ), std::end( array2 ), std::begin( array3 ),
    []( const char item ) -> int { return item; } 
);

template <typename T>
struct NameOf {};

#define DEF_TYPENAME(type) template <> \
struct NameOf<type> {\
    static const char value[];\
};\
const char NameOf<type>::value[] = #type;

DEF_TYPENAME(int)
DEF_TYPENAME(double)
DEF_TYPENAME(long double)
DEF_TYPENAME(float)
DEF_TYPENAME(char)
DEF_TYPENAME(long)
DEF_TYPENAME(unsigned)
DEF_TYPENAME(unsigned long)

template <typename T, typename ...types>
void printTypes(T)
{
    std::cout << NameOf<T>::value << std::endl;
}

template <typename T, typename ...types>
void printTypes(T, types... t)
{
    std::cout << NameOf<T>::value << ", ";
    printTypes(t...);
}

template <typename T, typename ...types>
void printTypes(T, types... t)
{
    std::cout << NameOf<T>::value << ", ";
    printTypes(t...);
}

class Fireball: public IMagicSpell {
  public:
    Fireball() {
      SpellInfo.Name = "Огненный шар";
      SpellInfo.Description = "Мощный огненный шар, сметающий все на своем пути.";
      SpellInfo.Type = fire;
      SpellInfo.MinDamage = 30;
      SpellInfo.MaxDamage = 50;
      SpellInfo.Range = 40;
      SpellInfo.Distance = 120;
    }

    virtual ~Fireball() {}

    virtual void Use() {
      cout << "Boom!" << endl;
    }
};

1. private - приватный доступ, только для экземпляра текущего класса;
   
2. protected - ограниченный доступ, только для экземпляров текущего класса и всех публичных наследников; доступ ограничивается при ограниченном или приватном наследовании;
   
3. public - публичный доступ, для всех пользователей экземпляров класса.
   

class IMagicSpell {
  protected:
    MagicSpellInfo SpellInfo;

  public:
    virtual ~IMagicSpell() {}
    virtual void Use() {}

    MagicSpellInfo GetInfo() {
      return this->SpellInfo;
    }

    void ShowDebugInfo() {
      cout << "Название: " << SpellInfo.Name << endl;
      cout << "Описание: " << SpellInfo.Description << endl;
      cout << "Тип: " << SpellInfo.Type << endl;
      cout << "Мин. урон: " << SpellInfo.MinDamage << endl;
      cout << "Макс. урон: " << SpellInfo.MaxDamage << endl;
      cout << "Расстояние: " << SpellInfo.Distance << endl;
      cout << "Радиус: " << SpellInfo.Range << endl;
    }
};

#ifdef DEBUG
#define debug(n) Serial.println("***"+String(n)+"***")
#else
#define debug(n)
#endif

namespace std
{
    // use the `Book` type definitely from global namespace.
    ofstream& operator<<(ofstream &of, const ::Book &book)
    {
        // ...
    }
}

И еще вопрос: что нужно возвращать из этой функции?

double GetCurrentTime()
{
	using Duration = std::chrono::duration<double>;
	return std::chrono::duration_cast<Duration>( 
		std::chrono::high_resolution_clock::now().time_since_epoch() 
	).count();
}

const double frame_delay = 1.0 / 60.0; // 60 FPS
double last_render = 0;
void OnIdle()
{
	const double current_time = GetCurrentTime();
	if( ( current_time - last_render ) > frame_delay )
	{
		last_render = current_time;
		glutPostRedisplay();
	}
}