矫情的C++——不明确行为（undefined behavior）

1. 使用未经初始化的（尤其是基本类型）局部变量

void foo()
{
    int a;
    ++a;        // 错误，使用了未经初始化的局部变量
}

void foo()
{
    int* p = 0;
    std::cout << *p;    // 提领一个null指针，将会导致不明确行为
}

基本类型不像类类型，会隐式地调用其默认构造函数，更详细的内容参见

void foo()
{
    int a = int();      
            // == (int a = 0;), 
            // 使用类型初始化的形式是为了保持基本类型和类类型形式上的统一，尤其在涉及到模板时
}

2. 当derived class 对象经由一个base class指针删除，而该base class带着一个non-virtual 析构函数

这里最好记住几个结论：
- 如果class不含virtual函数，通常表示它并不意图被用作一个base class
- 当一个class不企图被当做base class，令其虚构函数为virtual往往是个坏主意
- 任何class只要带有virtual函数（客制化）都几乎确定应该也有一个virtual 析构函数
- 只有当class内至少函一个virtual函数，就应当为其声明virtual析构函数

3. transform 两个输入区间的长度不一致时

在STL的算法（<algorithm>）实现中，一般针对某一函数（也即是某一特定算法）都有两个版本（或者叫函数重载），一种是基础版本，一种是泛化版本。

transform算法的遍历基准是第一输入序列。

template<typename InputIterator, typename OutputIterator, 
                        typename UnaryOperation>
OutputIterator transform(InputIterator first, InputIterator last, 
                        OutputIterator resutl, UnaryOperation op)
{
    for (; first != last; ++first, ++result)
    {
        // 这里要保证OutputIterator的长度不能低于InputIterator的长度
        *result = op(*first);
    }
    return result;
}

template<typename InputIterator, typename OutputIterator, 
            typename BinaryOperation>
OutputIterator transform(InputIterator first1, InputIterator last1,
            InputIterator first2, InputIterator last2, 
            BinaryOperation binary_op)
{
    for(; first1 != last1; ++first1, ++first2, ++result)    
    {
        // 这里不仅要保证输出序列的长度不能低于第一个输入序列与的长度
        // 而且要保证第二个输入序列的长度不能低于第一个输入序列的长度
        *result = binary_op(*first1, *first2);
    }
    return result;
}

• 版本1和版本2都会存在的undefined behavior是:

  输出序列（OutputIterator）的有效长度低于输入序列（InputIterator）的长度

• 版本2可能出现的undefined behavior：

  第二个输入序列（InputIterator 2） 的长度低于第一个输入序列（InputIterator 1）的长度

这里仅要求输出序列的长度不低于输入序列的长度，而不要求严格相等。

4. static_cast 执行向下类型转换时

class B
{
public:
    virtual void foo() {}
};

class D :public B
{};

当父类指针指向子类对象时，使用static_cast是没有问题的：

B* b = new D;
D* d1 = static_cast<D*>(b);
D* d2 = dynamic_cast<D*>(b);

当父类指针指向父类对象时，使用static_cast存在安全问题的，或者再使用static_cast进行强制向下类型转换就会出现undefined behavior：

B* b = new B;
D* d1 = static_cast<D*>(b);
                    // 使用 d1 访问属于D的成员时，即为undefined behavior

D* d2 = dynamic_cast<D*>(b);
                    // 返回 nullptr