C++的隐藏功能？

数组运算符是关联的.

A [8]是*(A + 8)的同义词.由于加法是关联的,可以改写为*(8 + A),这是..... 8 [A]的同义词

你没说有用...... :-)

有一点鲜为人知的是,工会也可以是模板:

template
union union_cast {
    From from;
    To   to;

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

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

他们也可以拥有构造函数和成员函数.没有任何与继承(包括虚函数)有关的事情.

C++是一个标准,不应该有任何隐藏的功能......

C++是一种多范式语言,你可以把最后的钱押在那里隐藏的功能.许多例子中的一个例子:模板元编程.标准委员会中没有人打算在编译时执行图灵完整的子语言.

另一个在C中不起作用的隐藏功能是一元运算+符的功能.你可以用它来促进和腐朽各种各样的事物

将枚举转换为整数

+AnEnumeratorValue

以前具有枚举类型的枚举器值现在具有可以适合其值的完美整数类型.手动,你很难知道那种类型!例如,当您想为枚举实现重载运算符时,需要这样做.

从变量中获取值

您必须使用一个使用类内静态初始化程序而没有类外定义的类,但有时它无法链接？操作员可以帮助创建一个临时的,而不会对其类型产生任何假设或依赖

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

// This does something interesting...
template
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
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
}

与const引用相关的临时工的生命期是很少有人知道的.或者至少它是我最喜欢的C++知识,大多数人都不知道.

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

一个不常用的好功能是功能范围的try-catch块:

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

主要用法是将异常转换为其他异常类和重新抛出,或者在异常和基于返回的错误代码处理之间进行转换.

很多人都知道identity/ idmetafunction,但对于非模板情况,它有一个很好的用例:轻松编写声明:

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

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

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

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

它有助于大大解密C++声明!

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

一个非常隐蔽的功能是您可以在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中:

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

并在一个循环中:

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

(也适用于条件).但我不太确定这些是否都有用:)

防止逗号运算符调用运算符重载

有时您可以有效地使用逗号运算符,但是您希望确保没有用户定义的逗号运算符妨碍,因为例如您依赖于左侧和右侧之间的序列点,或者希望确保没有任何干扰所需的行动.这是void()进入游戏的地方:

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

忽略我为条件和代码提出的占位符.重要的是void(),它使编译器强制使用内置逗号运算符.这在实现traits类时也很有用,有时候也是如此.

构造函数中的数组初始化.例如,在类中,如果我们有一个数组int:

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

我们可以在构造函数中将数组中的所有元素初始化为其默认值(此处数组的所有元素为零):

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

哦,我可以提出一个宠物仇恨列表:

如果您打算使用多态,则析构函数必须是虚拟的

有时会默认初始化成员,有时则不会

本地clases不能用作模板参数(使它们不那么有用)

异常说明符:看起来很有用,但不是

函数重载隐藏具有不同签名的基类函数.

国际化没有有用的标准化(便携式标准宽字符集,任何人？我们必须等到C++ 0x)

从积极的一面

隐藏功能:功能尝试块.不幸的是我没有找到它的用途.是的我知道为什么他们添加它,但你必须重新抛出一个构造函数,这使它毫无意义.

在容器修改之后,值得仔细查看STL保证迭代器有效性,这可以让你做一些稍好的循环.

提升 - 这不是什么秘密,但它值得使用.

返回值优化(不明显,但标准特别允许)

Functors aka function objects aka operator().这被STL广泛使用.不是真正的秘密,但是操作符重载和模板的一个漂亮的副作用.

您可以访问任何类的受保护数据和函数成员,没有未定义的行为,并具有预期的语义.继续阅读,看看如何.另请阅读有关此问题的缺陷报告.

通常,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 &s) {
    // now, let's decide to mess with that stack!
    struct pillager : std::stack {
        static std::deque &get(std::stack &s) {
            // error: stack::c is protected
            return s.c;
        }
    };

    // haha, now let's inspect the stack's middle elements!
    std::deque &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 &s) {
    // now, let's decide to mess with that stack!
    struct pillager : std::stack {
        static std::deque &get(std::stack &s) {
            return s.*(pillager::c);
        }
    };

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

使用派生类中的using声明会更容易,这会使成员名称为public并引用基类的成员.

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

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

隐藏功能:

纯虚函数可以实现.常见的例子,纯虚拟析构函数.

如果函数抛出未在其异常规范中列出的异常,但该函数std::bad_exception在其异常规范中有异常,则会std::bad_exception自动转换并抛出异常.这样你至少会知道a bad_exception被扔了.在这里阅读更多.

功能尝试块

模板关键字在类模板中消除typedef的歧义.如果成员模板特的名字出现后.,->或::运营商,这个名字有明确限定的模板参数,以关键字template前缀的成员模板名称.在这里阅读更多.

函数参数默认值可以在运行时更改.在这里阅读更多.

A[i] 工作得很好 i[A]

可以修改类的临时实例!可以在临时对象上调用非const成员函数.例如:

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

在这里阅读更多.

如果:在ternary(?:)运算符表达式之前和之后存在两种不同的类型,则表达式的结果类型是两者中最常用的类型.例如:

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)
}

另一个隐藏的功能是您可以调用可以转换为函数指针或引用的类对象.对它们的结果进行重载分辨率,并且完全转发参数.

template
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 c(foo, bar);
  c(42); // calls foo
  c(42L); // calls bar
}

这些被称为"代理呼叫功能".

map::operator[]如果缺少键则创建条目并返回对缺省构造的条目值的引用.所以你可以写:

map 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它们来限制它们到文件范围.

在类模板中定义普通的朋友函数需要特别注意:

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

在此示例中,两个不同的实例创建两个相同的定义 - 直接违反ODR

因此,我们必须确保类模板的模板参数出现在该模板中定义的任何友元函数的类型中(除非我们想要阻止特定文件中多个类模板的实例化,但这是不太可能的).让我们将其应用于前一个示例的变体:

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

Creator one;     // generates ::feed(Creator*) 
Creator two;   // generates ::feed(Creator*) 

免责声明:我已经从C++模板:完整指南 /第8.4 节粘贴了这一部分

void函数可以返回void值

鲜为人知,但下面的代码很好

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

以及下面奇怪的一个

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

了解这一点,你可以在某些方面利用.一个例子:void函数不能返回一个值,但你也不能只返回任何值,因为它们可以用非void实例化.不是将值存储到将导致错误的局部变量中,而是void直接返回值

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

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

将文件读入字符串向量:

 vector V;
 copy(istream_iterator(cin), istream_iterator(),
     back_inserter(V));

istream_iterator

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

template 
struct bitfield
{
    char left  : X;
    char right : Y;
};

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

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

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

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;

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

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

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(); } };

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
}

struct MyAwesomeAbstractClass
{ ... };


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

    return new ans(...);
}

int i(3);

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