Скрытые возможности C++?

Я не уверен насчет скрытого, но есть некоторые интересно'ухищрения', которые, вероятно, не очевидны после простого чтения спецификации.

C++ is a standard, there shouldn't be any hidden features...

C++ - это многопарадигмальный язык, вы можете поставить последние деньги на наличие скрытых функций. Один пример из многих: метапрограммирование шаблона. Никто в комитете по стандартам не намеревался создать полный по Тьюрингу подъязык, который будет выполняться во время компиляции.

Я нашел этот блог прекрасным ресурсом о секретах C++: Истины C++.

Здесь нет скрытых функций, но язык C++ очень мощный, и часто даже разработчики стандартов не могли представить, для чего можно использовать C++.

На самом деле, используя достаточно простую языковую конструкцию, вы можете написать что-нибудь очень мощное. Многие из таких вещей доступны на www.boost.org в качестве примеров (и http://www.boost.org/doc/libs/1_36_0/doc/html/lambda.html среди них).

Чтобы понять, как простая языковая конструкция может быть объединена с чем-то мощным, полезно прочитать "Шаблоны C++: полное руководство" Дэвида Вандевурда, Николая М. Йосаттиса и действительно волшебную книгу «Современный дизайн на C++ ...» Андрея Александреску.

И, наконец, С ++ сложно выучить, надо попробовать его залить;)

Есть много «неопределенного поведения». Вы можете узнать, как избежать чтения хороших книг и стандартов.

В C++ существует масса «хитрых» конструкций. Они идут от «простых» реализаций закрытые / финальные классы с использованием виртуального наследования. И переходите к довольно «сложным» конструкциям метапрограммирования, таким как MPL (руководство) Boost. Возможности для стрельбы себе в ногу безграничны, но если их контролировать (например, опытные программисты), они обеспечивают лучшую гибкость с точки зрения ремонтопригодности и производительности.

One example out of many: template metaprogramming. Nobody in the standards committee intended there to be a Turing-complete sublanguage that gets executed at compile-time.

Метапрограммирование шаблонов вряд ли является скрытой функцией. Это даже в библиотеке наддува. См. MPL. Но если «почти скрыто» достаточно, взгляните на увеличить библиотеки. Он содержит много полезных вещей, которые нелегко получить без поддержки сильной библиотеки.

Одним из примеров является библиотека boost.lambda, которая интересна, поскольку C++ не имеет лямбда-функций в текущем стандарте.

Другой пример - Локи, который «широко использует метапрограммирование шаблонов C++ и реализует несколько часто используемых инструментов: список типов, функтор, синглтон, интеллектуальный указатель, фабрику объектов, посетитель и мультиметоды». [Википедия]

О времени жизни временных файлов, привязанных к константным ссылкам, мало кто знает. Или, по крайней мере, это моя любимая часть знаний о C++, о которой большинство людей не знает.

const MyClass& x = MyClass(); // temporary exists as long as x is in scope

Оператор массива ассоциативен.

A [8] является синонимом * (A + 8). Поскольку сложение ассоциативно, его можно переписать как * (8 + A), что является синонимом ..... 8 [A]

Вы не сказали, что полезно ... :-)

Большинство разработчиков C++ игнорируют возможности метапрограммирования шаблонов. Проверьте Loki Libary. Он реализует несколько расширенных инструментов, таких как список типов, функтор, синглтон, интеллектуальный указатель, фабрика объектов, посетитель и мультиметоды, широко использующие метапрограммирование шаблонов (из википедия). По большей части вы можете рассматривать их как «скрытую» функцию C++.

Я согласен с большинством постов там: C++ - это язык с множеством парадигм, поэтому «скрытые» функции, которые вы найдете (кроме «неопределенного поведения», которого вам следует избегать любой ценой), - это умное использование возможностей.

Большинство из этих возможностей не являются встроенными функциями языка, а основаны на библиотеках.

Наиболее важным является RAII, который часто игнорируется в течение многих лет разработчиками C++ из мира C. Перегрузка оператора часто неправильно понимается функцией, которая обеспечивает как поведение, подобное массиву (оператор индекса), операции, подобные указателям (интеллектуальные указатели), так и операции, подобные встроенным (умножение матриц.

Использование исключение часто затруднено, но при некоторой работе можно получить действительно надежный код с помощью спецификаций безопасность исключений (включая код, который не будет терпеть неудачу, или который будет иметь функции, подобные фиксации, которые будут успешными, или вернуться к своему исходное состояние).

Самая известная из «скрытых» функций C++ - это метапрограммирование шаблона, поскольку она позволяет вам частично (или полностью) выполнять вашу программу во время компиляции, а не во время выполнения. Однако это сложно, и вы должны хорошо разбираться в шаблонах, прежде чем пробовать это делать.

Другие используют множественную парадигму для создания «способов программирования» вне предка C++, то есть C.

Используя функторы, вы можете моделировать функции с дополнительной безопасностью типов и с отслеживанием состояния. Используя шаблон команда, вы можете отложить выполнение кода. Большинство других шаблоны проектирования могут быть легко и эффективно реализованы на C++ для создания альтернативных стилей кодирования, которые не должны входить в список «официальных парадигм C++».

Используя шаблоны, вы можете создать код, который будет работать с большинством типов, включая не тот, который вы думали вначале. Вы также можете повысить безопасность типов (например, автоматический тип malloc / realloc / free). Возможности объектов C++ действительно мощные (и, следовательно, опасны при неосторожном использовании), но даже динамический полиморфизм имеет свою статическую версию в C++: CRTP.

Я обнаружил, что большинство книг типа "Эффективный C++" от Скотта Мейерса или книг типа "Исключительный C++" от Херба Саттера одновременно легко читаются и представляют собой кладезь информации об известных и менее известных особенностях C++.

Среди моих предпочтений есть тот, который должен вызвать ужас у любого Java-программиста: в C++ это наиболее объектно-ориентированный способ добавить функцию к объекту - использовать функцию, не являющуюся членом, не являющуюся другом, вместо функции-члена (т.е. метод класса), потому что:

• В C++ интерфейс класса - это как его функции-члены, так и функции, не являющиеся членами, в одном и том же пространстве имен.

• не являющиеся друзьями функции, не являющиеся членами, не имеют привилегированного доступа к внутреннему классу. Таким образом, использование функции-члена вместо не-члена, не являющегося другом, ослабит инкапсуляцию класса.

Это не перестает удивлять даже опытных разработчиков.

(Источник: среди прочего, онлайн-гуру недели Херба Саттера № 84: http://www.gotw.ca/gotw/084.htm)

Ооо, вместо этого я могу составить список ненависти к животным:

• Деструкторы должны быть виртуальными, если вы собираетесь использовать их полиморфно.
• Иногда члены инициализируются по умолчанию, иногда нет.
• Локальные классы нельзя использовать в качестве параметров шаблона (что делает их менее полезными)
• спецификаторы исключений: выглядят полезными, но не
• перегрузки функций скрывают функции базового класса с разными сигнатурами.
• нет полезной стандартизации по интернационализации (переносимая стандартная широкая кодировка, кто-нибудь? Нам придется подождать до C++ 0x)

С положительной стороны

• скрытая особенность: функциональные блоки try. К сожалению, я не нашел ему применения. Да, я знаю, почему они добавили его, но вам нужно повторно добавить конструктор, что делает его бессмысленным.
• Стоит внимательно изучить гарантии STL относительно допустимости итератора после модификации контейнера, что может позволить вам сделать несколько более приятных циклов.
• Boost - это вряд ли секрет, но стоит использовать.
• Оптимизация возвращаемого значения (неочевидно, но специально разрешено стандартом)
• Функторы, известные как функциональные объекты, также известные как operator (). Это широко используется STL. на самом деле не секрет, но это отличный побочный эффект перегрузки операторов и шаблонов.

Одна языковая функция, которую я считаю несколько скрытой, потому что я никогда не слышал о ней за все время учебы в школе, - это псевдоним пространства имен. Это не было доведено до моего сведения, пока я не встретил его примеры в документации по усилению. Конечно, теперь, когда я знаю об этом, вы можете найти его в любом стандартном справочнике по C++.

namespace fs = boost::filesystem;

fs::path myPath( strPath, fs::native );

• указатели на методы класса
• Ключевое слово "typename"

Вы можете без ошибок помещать URI в исходный код C++. Например:

void foo() {
    http://stackoverflow.com/
    int bar = 4;

    ...
}

Указатель арифметики.

На самом деле это функция C, но я заметил, что немногие люди, использующие C / C++, действительно знают, что она вообще существует. Я считаю, что эта особенность языка C действительно свидетельствует о гениальности и видении его изобретателя.

Короче говоря, арифметика указателей позволяет компилятору выполнять [n] как * (a + n) для любого типа a. В качестве примечания, поскольку '+' коммутативен, a [n], конечно, эквивалентно n [a].

Избавляемся от форвардных объявлений:

struct global
{
     void main()
     {
           a = 1;
           b();
     }
     int a;
     void b(){}
}
singleton;

Написание операторов switch с помощью операторов?::

string result = 
    a==0 ? "zero" :
    a==1 ? "one" :
    a==2 ? "two" :
    0;

Делаем все в одной строке:

void a();
int b();
float c = (a(),b(),1.0f);

Обнуление структур без memset:

FStruct s = {0};

Нормализация / обертывание значений угла и времени:

int angle = (short)((+180+30)*65536/360) * 360/65536; //==-150

Назначение референсов:

struct ref
{
   int& r;
   ref(int& r):r(r){}
};
int b;
ref a(b);
int c;
*(int**)&a = &c;

Приятной особенностью, которая используется нечасто, является блок try-catch для всей функции:

int Function()
try
{
   // do something here
   return 42;
}
catch(...)
{
   return -1;
}

Основное использование будет заключаться в преобразовании исключения в другой класс исключения и повторном вызове или в преобразовании между исключениями и обработкой кода ошибки на основе возврата.

Скрытые возможности:

1. Чистые виртуальные функции могут иметь реализацию. Типичный пример, чистый виртуальный деструктор.

2. Если функция генерирует исключение, не указанное в ее спецификациях исключения, но функция имеет std::bad_exception в своей спецификации исключения, исключение преобразуется в std::bad_exception и генерируется автоматически. Таким образом вы хотя бы узнаете, что был брошен bad_exception. Узнать больше здесь.

3. функциональные блоки try

4. Ключевое слово template для устранения неоднозначности определений типов в шаблоне класса. Если имя специализации шаблона элемента появляется после оператора ., -> или ::, и это имя имеет явно определенные параметры шаблона, добавьте к имени шаблона элемента префикс ключевого слова template. Узнать больше здесь.

5. Значения по умолчанию для параметров функции могут быть изменены во время выполнения. Узнать больше здесь.

6. A[i] работает так же хорошо, как i[A]

7. Временные экземпляры класса можно изменять! Неконстантная функция-член может быть вызвана для временного объекта. Например:

   struct Bar {
     void modify() {}
   }
   int main (void) {
     Bar().modify();   /* non-const function invoked on a temporary. */
   }
   

   Узнать больше здесь.

8. Если два разных типа присутствуют до и после : в тернарном (?:) операторном выражении, то результирующий тип выражения является наиболее общим из двух. Например:

   void foo (int) {}
   void foo (double) {}
   struct X {
     X (double d = 0.0) {}
   };
   void foo (X) {} 
   
   int main(void) {
     int i = 1;
     foo(i ? 0 : 0.0); // calls foo(double)
     X x;
     foo(i ? 0.0 : x);  // calls foo(X)
   }
   

Инициализация массива в конструкторе. Например, в классе, если у нас есть массив int как:

class clName
{
  clName();
  int a[10];
};

Мы можем инициализировать все элементы в массиве по умолчанию (здесь все элементы массива равны нулю) в конструкторе как:

clName::clName() : a()
{
}

map::operator[] создает запись, если ключ отсутствует, и возвращает ссылку на созданное по умолчанию значение записи. Итак, вы можете написать:

map<int, string> m;
string& s = m[42]; // no need for map::find()
if (s.empty()) { // assuming we never store empty values in m
  s.assign(...);
}
cout << s;

Я поражен тем, сколько программистов на C++ этого не знают.

Помещение функций или переменных в безымянное пространство имен осуждает использование static, чтобы ограничить их областью файлов.

Большинство программистов на C++ знакомы с тернарным оператором:

x = (y < 0) ? 10 : 20;

Однако они не понимают, что его можно использовать как lvalue:

(a == 0 ? a : b) = 1;

что является сокращением для

if (a == 0)
    a = 1;
else
    b = 1;

Используйте с осторожностью :-)

Считываем файл в вектор строк:

 vector<string> V;
 copy(istream_iterator<string>(cin), istream_iterator<string>(),
     back_inserter(V));

istream_iterator

Pointer arithmetics.

Программисты на C++ предпочитают избегать указателей из-за возможных ошибок.

Но самый крутой C++, который я когда-либо видел? Аналоговые литералы.

Довольно скрытая особенность заключается в том, что вы можете определять переменные внутри условия if, и его область действия будет охватывать только if и его блоки else:

if (int * p = getPointer()) {
    // do something
}

Некоторые макросы используют это, например, чтобы обеспечить некоторую "заблокированную" область видимости, например:

struct MutexLocker { 
    MutexLocker(Mutex&);
    ~MutexLocker(); 
    operator bool() const { return false; } 
private:
    Mutex &m;
};

#define locked(mutex) if (MutexLocker const& lock = MutexLocker(mutex)) {} else 

void someCriticalPath() {
    locked(myLocker) { /* ... */ }
}

Также BOOST_FOREACH использует его под капотом. Чтобы завершить это, это возможно не только в if, но и в переключателе:

switch(int value = getIt()) {
    // ...
}

и в цикле while:

while(SomeThing t = getSomeThing()) {
    // ...
}

(а также в состоянии for). Но я не уверен, насколько они полезны :)

От Истины C++.

Определение функций с идентичными подписями в одной и той же области, поэтому это допустимо:

template<class T> // (a) a base template
void f(T) {
  std::cout << "f(T)\n";
}

template<>
void f<>(int*) { // (b) an explicit specialization
  std::cout << "f(int *) specilization\n";
}

template<class T> // (c) another, overloads (a)
void f(T*) {
  std::cout << "f(T *)\n";
}

template<>
void f<>(int*) { // (d) another identical explicit specialization
  std::cout << "f(int *) another specilization\n";
}

Если оператор delete () принимает аргумент размера в дополнение к * void, это означает, что он будет, в значительной степени, базовым классом. Этот аргумент размера делает возможной проверку размера типов, чтобы уничтожить правильный. Вот что об этом сообщает Стивен Дьюхерст:

Notice also that we've employed a two-argument version of operator delete rather than the usual one-argument version. This two-argument version is another "usual" version of member operator delete often employed by base classes that expect derived classes to inherit their operator delete implementation. The second argument will contain the size of the object being deleted—information that is often useful in implementing custom memory management.

Одна из самых интересных грамматик любого языка программирования.

Три из этих вещей принадлежат друг другу, а две совершенно разные ...

SomeType t = u;
SomeType t(u);
SomeType t();
SomeType t;
SomeType t(SomeType(u));

Все, кроме третьего и пятого, определяют объект SomeType в стеке и инициализируют его (с помощью u в первых двух случаях и конструктором по умолчанию в четвертом. Третий объявляет функцию, которая не принимает параметров и возвращает SomeType. Пятый аналогичным образом объявляет функцию, которая принимает один параметр по значению типа SomeType с именем u.

Мало что известно о том, что союзы тоже могут быть шаблонами:

template<typename From, typename To>
union union_cast {
    From from;
    To   to;

    union_cast(From from)
        :from(from) { }

    To getTo() const { return to; }
};

И у них тоже могут быть конструкторы и функции-члены. Ничего общего с наследованием (включая виртуальные функции).

Особого внимания требует определение обычных функций друзей в шаблонах классов:

template <typename T> 
class Creator { 
    friend void appear() {  // a new function ::appear(), but it doesn't 
        …                   // exist until Creator is instantiated 
    } 
};
Creator<void> miracle;  // ::appear() is created at this point 
Creator<double> oops;   // ERROR: ::appear() is created a second time! 

В этом примере два разных экземпляра создают два идентичных определения - прямое нарушение ODR

Поэтому мы должны убедиться, что параметры шаблона шаблона класса присутствуют в типе любой дружественной функции, определенной в этом шаблоне (если мы не хотим предотвратить создание более одного экземпляра шаблона класса в конкретном файле, но это маловероятно). Давайте применим это к варианту нашего предыдущего примера:

template <typename T> 
class Creator { 
    friend void feed(Creator<T>*){  // every T generates a different 
        …                           // function ::feed() 
    } 
}; 

Creator<void> one;     // generates ::feed(Creator<void>*) 
Creator<double> two;   // generates ::feed(Creator<double>*) 

Отказ от ответственности: я вставил этот раздел из Шаблоны C++: полное руководство / Раздел 8.4

Опасный секрет

Fred* f = new(ram) Fred(); http://www.parashift.com/c++-faq-lite/dtors.html#faq-11.10
f->~Fred();

Мой любимый секрет, который я редко использую:

class A
{
};

struct B
{
  A a;
  operator A&() { return a; }
};

void func(A a) { }

int main()
{
  A a, c;
  B b;
  a=c;
  func(b); //yeah baby
  a=b; //gotta love this
}

class Empty {};

namespace std {
  // #1 specializing from std namespace is okay under certain circumstances
  template<>
  void swap<Empty>(Empty&, Empty&) {} 
}

/* #2 The following function has no arguments. 
   There is no 'unknown argument list' as we do
   in C.
*/
void my_function() { 
  cout << "whoa! an error\n"; // #3 using can be scoped, as it is in main below
  // and this doesn't affect things outside of that scope
}

int main() {
  using namespace std; /* #4 you can use using in function scopes */
  cout << sizeof(Empty) << "\n"; /* #5 sizeof(Empty) is never 0 */
  /* #6 falling off of main without an explicit return means "return 0;" */
}

Идиома косвенного преобразования:

Suppose you're designing a smart pointer class. In addition to overloading the operators * and ->, a smart pointer class usually defines a conversion operator to bool:

template <class T>
class Ptr
{
public:
 operator bool() const
 {
  return (rawptr ? true: false);
 }
//..more stuff
private:
 T * rawptr;
};

The conversion to bool enables clients to use smart pointers in expressions that require bool operands:

Ptr<int> ptr(new int);
if (ptr ) //calls operator bool()
 cout<<"int value is: "<<*ptr <<endl;
else
 cout<<"empty"<<endl;

Furthermore, the implicit conversion to bool is required in conditional declarations such as:

if (shared_ptr<X> px = dynamic_pointer_cast<X>(py))
{
 //we get here only of px isn't empty
} 

Alas, this automatic conversion opens the gate to unwelcome surprises:

Ptr <int> p1;
Ptr <double> p2;

//surprise #1
cout<<"p1 + p2 = "<< p1+p2 <<endl; 
//prints 0, 1, or 2, although there isn't an overloaded operator+()

Ptr <File> pf;
Ptr <Query> pq; // Query and File are unrelated 

//surprise #2
if (pf==pq) //compares bool values, not pointers! 

Решение: используйте идиому «косвенное преобразование», преобразовав указатель в член данных [pMember] в bool, чтобы было только одно неявное преобразование, которое предотвратит вышеупомянутое неожиданное поведение: pMember-> bool, а не bool-> something еще.

Обратите внимание на разницу между инициализацией указателя на бесплатную функцию и указателя на функцию-член:

функция-член:

struct S
{
 void func(){};
};
int main(){
void (S::*pmf)()=&S::func;//  & is mandatory
}

и бесплатная функция:

void func(int){}
int main(){
void (*pf)(int)=func; // & is unnecessary it can be &func as well; 
}

Благодаря этому избыточному & вы можете добавлять манипуляторы потоков, которые являются бесплатными функциями, в цепочку без него:

cout<<hex<<56; //otherwise you would have to write cout<<&hex<<56, not neat.

Может ли шаблон C++ проверять существование функции?

Эмуляция переосмыслить актерский состав с помощью статический бросок:

int var;
string *str = reinterpret_cast<string*>(&var);

приведенный выше код эквивалентен следующему:

int var;    
string *str = static_cast<string*>(static_cast<void*>(&var));

Класс и структура class-keys почти идентичны. Основное отличие состоит в том, что классы по умолчанию имеют частный доступ для членов и баз, а структуры по умолчанию - общедоступные:

// this is completely valid C++:
class A;
struct A { virtual ~A() = 0; };
class B : public A { public: virtual ~B(); };

// means the exact same as:
struct A;
class A { public: virtual ~A() = 0; };
struct B : A { virtual ~B(); };

// you can't even tell the difference from other code whether 'struct'
// or 'class' was used for A and B

Объединения также могут иметь члены и методы и по умолчанию имеют общий доступ, как и структуры.

В части инициализации цикла for можно объявлять не только переменные, но также классы и функции.

for(struct { int a; float b; } loop = { 1, 2 }; ...; ...) {
    ...
}

Это позволяет использовать несколько переменных разных типов.

Добавление ограничения в шаблоны.

У примитивных типов есть конструкторы.

int i(3);

работает.

Мне кажется, что о безымянных пространствах имен мало кто знает:

namespace {
  // Classes, functions, and objects here.
}

Безымянные пространства имен ведут себя так, как если бы они были заменены:

namespace __unique_name__ { /* empty body */ }
using namespace __unique_name__;
namespace __unique_name__ {
  // original namespace body
}

«.. где все вхождения [этого уникального имени] в единице перевода заменены одним и тем же идентификатором, и этот идентификатор отличается от всех других идентификаторов во всей программе». [C++ 03, 7.3.1.1/1]

Вы можете получить доступ к защищенным данным и функциям любого класса без неопределенного поведения и с ожидаемой семантикой. Читайте дальше, чтобы узнать, как это сделать. Прочтите также об этом отчет о дефектах.

Обычно C++ запрещает вам доступ к нестатическим защищенным членам объекта класса, даже если этот класс является вашим базовым классом.

struct A {
protected:
    int a;
};

struct B : A {
    // error: can't access protected member
    static int get(A &x) { return x.a; }
};

struct C : A { };

Это запрещено: вы и компилятор не знаете, на что на самом деле указывает ссылка. Это может быть объект C, и в этом случае класс B не имеет никакого отношения к своим данным. Такой доступ предоставляется только в том случае, если x является ссылкой на производный класс или производный от него. И он может позволить произвольному фрагменту кода читать любой защищенный член, просто создавая «одноразовый» класс, который считывает члены, например std::stack:

void f(std::stack<int> &s) {
    // now, let's decide to mess with that stack!
    struct pillager : std::stack<int> {
        static std::deque<int> &get(std::stack<int> &s) {
            // error: stack<int>::c is protected
            return s.c;
        }
    };

    // haha, now let's inspect the stack's middle elements!
    std::deque<int> &d = pillager::get(s);
}

Конечно, как видите, это нанесет слишком большой ущерб. Но теперь указатели на элементы позволяют обойти эту защиту! Ключевым моментом является то, что тип указателя члена привязан к классу, который фактически содержит упомянутый член - нет к классу, который вы указали при получении адреса. Это позволяет нам обойти проверку

struct A {
protected:
    int a;
};

struct B : A {
    // valid: *can* access protected member
    static int get(A &x) { return x.*(&B::a); }
};

struct C : A { };

И, конечно же, это также работает с примером std::stack.

void f(std::stack<int> &s) {
    // now, let's decide to mess with that stack!
    struct pillager : std::stack<int> {
        static std::deque<int> &get(std::stack<int> &s) {
            return s.*(pillager::c);
        }
    };

    // haha, now let's inspect the stack's middle elements!
    std::deque<int> &d = pillager::get(s);
}

Это будет еще проще с объявлением using в производном классе, которое делает имя члена общедоступным и ссылается на член базового класса.

void f(std::stack<int> &s) {
    // now, let's decide to mess with that stack!
    struct pillager : std::stack<int> {
        using std::stack<int>::c;
    };

    // haha, now let's inspect the stack's middle elements!
    std::deque<int> &d = s.*(&pillager::c);
}

Указатели на элементы и оператор указателя на член -> *

#include <stdio.h>
struct A { int d; int e() { return d; } };
int main() {
    A* a = new A();
    a->d = 8;
    printf("%d %d\n", a ->* &A::d, (a ->* &A::e)() );
    return 0;
}

Для методов (a -> * & A :: e) () немного похож на Function.call () из javascript

var f = A.e
f.call(a) 

Для участников это немного похоже на доступ с помощью оператора []

a['d']

Многие знают о метафункции identity / id, но есть хороший вариант использования для случаев, не связанных с шаблоном: Простота написания объявлений:

// void (*f)(); // same
id<void()>::type *f;

// void (*f(void(*p)()))(int); // same
id<void(int)>::type *f(id<void()>::type *p);

// int (*p)[2] = new int[10][2]; // same
id<int[2]>::type *p = new int[10][2];

// void (C::*p)(int) = 0; // same
id<void(int)>::type C::*p = 0;

Это очень помогает при расшифровке объявлений C++!

// boost::identity is pretty much the same
template<typename T> 
struct id { typedef T type; };

бросить это выражение

Я считаю, что создание рекурсивных шаблонов довольно круто:

template<class int>
class foo;

template
class foo<0> {
    int* get<0>() { return array; }
    int* array;  
};

template<class int>
class foo<i> : public foo<i-1> {
    int* get<i>() { return array + 1; }  
};

Я использовал это для создания класса с 10-15 функциями, которые возвращают указатели на различные части массива, поскольку используемый мной API требовал одного указателя на функцию для каждого значения.

Т.е. программирование компилятора для генерации набора функций с помощью рекурсии. Проще простого. :)

main () не требует возвращаемого значения:

int main(){}

это самая короткая действующая программа на C++.

Вы можете использовать шаблоны битовых полей.

template <size_t X, size_t Y>
struct bitfield
{
    char left  : X;
    char right : Y;
};

Я еще не придумал для этого какой-либо цели, но это, черт возьми, меня удивило.

Мне больше всего нравится (на данный момент) отсутствие сематики в таких утверждениях, как А = В = С. Какое значение A в основном не определено.

Подумайте об этом:

class clC
{
public:
   clC& operator=(const clC& other)
   {
      //do some assignment stuff
      return copy(other);
   }
   virtual clC& copy(const clC& other);
}

class clB : public clC
{
public:
  clB() : m_copy()
  {
  }

  clC& copy(const clC& other)
  {
    return m_copy;
  }

private:
  class clInnerB : public clC
  {
  }
  clInnerB m_copy;
}

теперь A может иметь тип, недоступный для каких-либо объектов, кроме объектов типа clB, и иметь значение, не связанное с C.

функции void могут возвращать значения void

Малоизвестно, но следующий код подойдет

void f() { }
void g() { return f(); }

А также следующий странно выглядящий

void f() { return (void)"i'm discarded"; }

Зная об этом, вы можете воспользоваться преимуществами в некоторых сферах. Один пример: функции void не могут возвращать значение, но вы также можете не просто ничего не возвращать, потому что они могут быть созданы с непустым. Вместо сохранения значения в локальной переменной, что вызовет ошибку для void, просто верните значение напрямую.

template<typename T>
struct sample {
  // assume f<T> may return void
  T dosomething() { return f<T>(); }

  // better than T t = f<T>(); /* ... */ return t; !
};

Предотвращение вызова оператора запятой перегрузок оператора

Иногда вы правильно используете оператор запятой, но вы хотите, чтобы ни один пользовательский оператор запятой не мешал, потому что, например, вы полагаетесь на точки последовательности между левой и правой стороной или хотите убедиться, что ничто не мешает желаемому действие. Вот где в игру вступает void():

for(T i, j; can_continue(i, j); ++i, void(), ++j)
  do_code(i, j);

Не обращайте внимания на заполнители, которые я поставил для условия и кода. Что важно, так это void(), который заставляет компилятор использовать встроенный оператор запятой. Иногда это может быть полезно при реализации классов признаков.

Вы можете просмотреть все предопределенные макросы с помощью переключателей командной строки с некоторыми компиляторами. Это работает с gcc и icc (компилятор Intel C++):

$ touch empty.cpp
$ g++ -E -dM empty.cpp | sort >gxx-macros.txt
$ icc -E -dM empty.cpp | sort >icx-macros.txt
$ touch empty.c
$ gcc -E -dM empty.c | sort >gcc-macros.txt
$ icc -E -dM empty.c | sort >icc-macros.txt

Для MSVC они перечислены в единственное место. Они могут быть задокументированы в одном месте и для других, но с помощью приведенных выше команд вы можете четко определить видеть, что определено, а что нет, и какие именно значения используются, после применения всех других параметров командной строки.

Сравните (после сортировки):

 $ diff gxx-macros.txt icx-macros.txt
 $ diff gxx-macros.txt gcc-macros.txt
 $ diff icx-macros.txt icc-macros.txt

Тернарный условный оператор ?: требует, чтобы его второй и третий операнды имели "приемлемые" типы (говоря неформально). Но это требование имеет одно исключение (каламбур): либо второй, либо третий операнд может быть выражением throw (имеющим тип void), независимо от типа другого операнда.

Другими словами, с помощью оператора ?: можно написать следующие правильно допустимые выражения C++.

i = a > b ? a : throw something();

Кстати, тот факт, что выражение throw на самом деле является выражение (типа void), а не оператором, является еще одной малоизвестной особенностью языка C++. Это, помимо прочего, означает, что следующий код абсолютно верен.

void foo()
{
  return throw something();
}

хотя в этом нет особого смысла (возможно, в каком-то универсальном коде шаблона это может пригодиться).

1. map::insert(std::pair(key, value)); не перезаписывает, если значение ключа уже существует.

2. Вы можете создать экземпляр класса сразу после его определения: (Я мог бы добавить, что эта функция дала мне сотни ошибок компиляции из-за отсутствия точки с запятой, и я никогда не видел, чтобы кто-то использовал ее в классах)

   class MyClass {public: /* code */} myClass;
   

Я знаю человека, который одновременно определяет геттер и сеттер только одним методом. Так:

class foo
{
    int x;

    int* GetX(){
        return &x;
    }
}

Теперь вы можете использовать это как получатель, как обычно (ну, почти):

int a = *GetX();

и как установщик:

*GetX() = 17;

Метапрограммирование шаблона есть.

На самом деле не скрытая функция, а чистая классность:

#define private public 

Вы можете вернуть ссылку на переменную как часть функции. У него есть несколько применений, в основном для создания ужасного кода:

int s ;
vector <int> a ;
vector <int> b ;

int &G(int h)
{
    if ( h < a.size() ) return a[h] ;
    if ( h - a.size() < b.size() ) return b[ h - a.size() ] ;
    return s ;
}

int main()
{
    a = vector <int> (100) ;
    b = vector <int> (100) ;

    G( 20) = 40 ; //a[20] becomes 40
    G(120) = 40 ; //b[20] becomes 40
    G(424) = 40 ; //s becomes 40
}

Классные местные классы:

struct MyAwesomeAbstractClass
{ ... };


template <typename T>
MyAwesomeAbstractClass*
create_awesome(T param)
{
    struct ans : MyAwesomeAbstractClass
    {
        // Make the implementation depend on T
    };

    return new ans(...);
}

довольно аккуратно, поскольку он не загрязняет пространство имен бесполезными определениями классов ...

Одна скрытая функция, даже скрытая для Разработчики GCC, - это инициализация элемента массива с помощью строкового литерала. Предположим, у вас есть структура, которая должна работать с массивом C, и вы хотите инициализировать член массива содержимым по умолчанию.

struct Person {
  char name[255];
  Person():name("???") { }
};

Это работает и работает только с массивами символов и инициализаторами строковых литералов. strcpy не требуется!

Еще одна скрытая особенность заключается в том, что вы можете вызывать объекты класса, которые можно преобразовать в указатели на функции или ссылки. Разрешение перегрузки выполняется по их результатам, и аргументы передаются безупречно.

template<typename Func1, typename Func2>
class callable {
  Func1 *m_f1;
  Func2 *m_f2;

public:
  callable(Func1 *f1, Func2 *f2):m_f1(f1), m_f2(f2) { }
  operator Func1*() { return m_f1; }
  operator Func2*() { return m_f2; }
};

void foo(int i) { std::cout << "foo: " << i << std::endl; }
void bar(long il) { std::cout << "bar: " << il << std::endl; }

int main() {
  callable<void(int), void(long)> c(foo, bar);
  c(42); // calls foo
  c(42L); // calls bar
}

Они называются «суррогатными функциями вызова».

Еще одна скрытая функция, которая не работает в C, - это функциональность унарного оператора +. Вы можете использовать его для продвижения и разложения всяких вещей

Преобразование перечисления в целое число

+AnEnumeratorValue

И значение вашего перечислителя, которое раньше имело тип перечисления, теперь имеет идеальный целочисленный тип, который может соответствовать его значению. Вручную вы вряд ли узнаете этот тип! Это необходимо, например, когда вы хотите реализовать перегруженный оператор для перечисления.

Получить значение из переменной

Вы должны использовать класс, который использует статический инициализатор внутри класса без определения вне класса, но иногда он не может связать? Оператор может помочь создать временный объект, не делая предположений или зависимостей от его типа.

struct Foo {
  static int const value = 42;
};

// This does something interesting...
template<typename T>
void f(T const&);

int main() {
  // fails to link - tries to get the address of "Foo::value"!
  f(Foo::value);

  // works - pass a temporary value
  f(+Foo::value);
}

Распад массива на указатель

Вы хотите передать функции два указателя, но это просто не сработает? Оператор может помочь

// This does something interesting...
template<typename T>
void f(T const& a, T const& b);

int main() {
  int a[2];
  int b[3];
  f(a, b); // won't work! different values for "T"!
  f(+a, +b); // works! T is "int*" both time
}

Правило доминирования полезно, но малоизвестно. В нем говорится, что даже если в неуникальном пути через решетку базового класса, поиск по имени частично скрытого члена уникален, если член принадлежит виртуальному базовому классу:

struct A { void f() { } };

struct B : virtual A { void f() { cout << "B!"; } };
struct C : virtual A { };

// name-lookup sees B::f and A::f, but B::f dominates over A::f !
struct D : B, C { void g() { f(); } };

Я использовал это для реализовать выравнивание-поддержку, который автоматически определяет строжайшее выравнивание с помощью правила доминирования.

Это относится не только к виртуальным функциям, но и к именам typedef, статическим / невиртуальным членам и всему остальному. Я видел, как он использовался для реализации перезаписываемых свойств в метапрограммах.