c++（五）、对象和类（三）

一、断言与常量表达式

1、常量表达式与c++11中的constexpr关键字

常量表达式是编译期可以计算值的一个表达式。

//eg.c++数组的大小要求是编译期的一个常量；
int n = 1;
n++;
std::array<int, n> a1;//error:n is not a constant expression;
const int m = 2;
std::array<int, m> a2;//ok,m is a constant expression;

而const 修饰的对象未必是编译期常量，如下所示：

const int r = n;//r is runtime constant,compiler does not konw its value
                // at compile-time;
r = ++n;//error:r is read-only;
std::array<int, r> a3;//error:r is not konwn at compile-time;

c++11中提供了编译期常量表达式说明符：constexpr，constexpr说明符声明可以在编译时计算函数或变量的值；

constexpr int max(int a, int b){
    if(a > b)
        return a;//c++14中才允许constexpr函数中有分支循环等；
    else
        return b;
}

int main(){
    int m = 1;
    const int r = m++;//r是运行期常量；
    const int rc = 4;//rc是编译期常量，等价于：constexpr int rc = 4;

    int a1[max(m, rc)];//error:m & rc 不是编译期常量；
    std::array<char, max(rc, 5)>a2;//ok，rc和5是编译期常量;
}

总结：const 和 constexpr的主要区别，const告知程序员const修饰的内容是不会被修改；constexpr用在所有被要求使用常量表达式的地方，constexpr修饰的东西要求可以在编译期计算得到的值，可以让编译器能够优化代码提升性能。

2、断言和c++11的静态断言

断言是一条检测假设成立与否的语句，例如c语言的宏（Macro）：assert，运行时检测，并且依赖于NDEBUG宏，而NDEBUG这个宏是c/c++标准规定的，所有编译器都有对它的支持。在调试（debug）模式编译时，编译器不会定义NDEBUG，所以assert()宏起作用，而在发行（release）模式下，编译器自动定义宏NDEBUG，使assert()不起作用。所以要强制使得assert()生效或不生效时，只要手动#define NDEBUG 或者 #undef NDEBUG即可。assert可以帮助调试解决逻辑bug。

//c语言中使用assert(),需要包含头文件<cassert>,并以调试模式编译程序
//用法:assert(bool_expr);//bool_expr为假则中断程序；

std::array<int, 3> a{1,2,3};

for(size_t i = 0;i <= a.size(); ++i){
    assert(i < 3);//断言，当i不小于3时，失败；
    std::cout << a[i];
    std::cout << (i == a.size() ? "" : " ");
}

当程序中的assert中断了程序时，标明程序中有了bug，此时程序员要解决bug，而不是把assert()放在这里当成程序的一部分。

2.1、c++11中的静态断言（static_assert）

用法：static_assert(bool_constexpr, message);

其中的两个参数：bool_constexpr，编译器常量表达式，可转换为bool类型；

                            message，字符串字面量，是断言失败时显示的警告信息，自c++17起，message是可选的。

静态断言的作用：编译时断言检查。

//下面的语句在64位平台上编译，就会报错
static_assert(sizeof(void*) == 4, "64-bit code generation is not supported.");

而static_assert()常用在模板中，对写库的作者用处大。

2.2、何时使用断言

在《代码大全2》中提到：若某些状况是你预期的，用错误处理；若某些状况永不改发生，用断言。

3、声明和定义

声明是引入标识符并描述其类型，无论是类型、对象或者函数，编译器需要该声明，以便识别在它处使用该标识符。

//这些都是声明；
extern int bar;
extern int a(int, int);
double f(int , double );
class foo;

定义是实例化或实现这个标识符。链接器需要定义，以便对标识符的引用链接到标识符所表示的实体。

//下面这些是定义
int bar;
int g(int a, int b){return (a+b);}
double f(int a, double b){return (a+b);}
class foo{};

由上可得声明和定义的区别：

（1）定义有时可取代声明，反之则不行；

（2）标识符可以被声明多次，但只能定义一次；

（3）定义通常伴随着编译器为标识符分配内存。

二、代理构造、不可变对象与静态成员

2.1、代理构造：一个构造函数可以调用另外的构造函数。

class A
{
public:
    A():A(0){}//初始化列表
    A(int i) : A(i, 0){}//初始化列表；
    A(int i, int j)
    {
        num1 = i;
        num2 = j;
        average = (num1 + num2)>>1;
    }

private:
    int num1;
    int num2;
    int average;
}

上述示例中构造函数的调用次序：A()->A(int)->A(int, int)。

在使用代理构造时要避免递归调用目标。

2.2、不可变对象和类

所谓不可变对象（immutable object）是指对象创建后，其内容不可改变，除非通过成员拷贝。

不可变类为不可变对象所属的类。

如一个类只有私有数据成员，且没有更改器set函数和能改变私有数据成员的函数，也没有能够返回可变数据域对象的引用或指针的访问器，则这些私有数据成员为不可变对象，这个类为不可变类。

2.3、实例成员与静态成员

在类定义中，关键字static声明不绑定到类实例的成员，即该成员无需创建对象即可访问。

静态数据成员定义规则：

（1）声明为constexpr类型的静态数据成员必须在类中声明并初始化，c++17起，可以不在类外定义；

（2）声明为inline（c++17起）或者const int类型的静态数据成员可以在类中声明并初始化；

（3）其他必须在类外定义并初始化，且不带static关键字；

静态数据成员定义规则复杂，在类外定义，不部分情况下不会出错。

静态数据成员具有静态存储期，对象的存储在程序开始时分配，在程序结束时解回收；并且未明确初始化时会被自动零初始化。

//如下numberOfObjects只存在一个，是由所有Square对象共享的，叫做静态成员；
//*.h
class Square{
private:
    double side;
    static int numberOfObjects;//用static初始化静态成员；
public:
    Square():Square(1.0){}

    Square(double side){
        this->side = side;
        numberOfObjects++;
    }

}



//*.cpp
int Square::numberOfObjects;
int main(){
    Square s1{},s2{5.0};
}