c++ 中的符号与关键字

符号按照符号的ASC码数值从小到达排列，关键字按照英文字母排序。

& 【38】

位运算；取地址；左值引用【指针、引用都是可以做类型转换的】

#include <iostream>

int main()
{
    int a = ;
    int b = ;

    std::cout << ( a&b )<< std::endl;    

    int* pa = &a;

    std::cout << ( *pa )<< std::endl;    

    int& ra = a;　　/*引用某种情况下类似于(*pa)*/

    std::cout << ( ra )<< std::endl;

    return ;
}

&& 【38 38】

逻辑运算；右值引用【注意：右值引用编译时候必须指定 --std=c++11】

int main()
{
    int a, b;

    a = ;
    b = ;
    if (a && b) {
        std::cout << "test if" << std::endl;
    } else {
        std::cout << "test else" << std::endl;
    }

    int&& ra = a+;

    std::cout << ra << std::endl;

    return ;
}

:: 【58 58】

指定名称空间

int main()
{
    std::cout << (int)':' << std::endl;
    return ;
}

const

表示对象不可变，定义时必须要初始化。

const对象只能调用const函数成员，反之，非const对象能调用const、非const函数成员。

const_cast

去除const属性。

const_cast<type_to_convert_to>(表达式)

delete

释放内存

dynamic_cast

动态强制类型转换

dynamic_cast<type_to_convert_to>(表达式)

explicit

当构造函数只有一个参数时，避免把参数的类型转换为类类型。

下边实例，构造函数不加explicit时，会将 50 转换成边长为 50 的 cube 然后跟 aCube比较。

给构造函数加上 explicit 时候，不允许类型转换，所以下边的main函数编译不通过。

class Cube {
    private :
        double side;
    public :
    Cube(double sideVaule) {
        side = sideVaule;
    }
        double volume() {
            return side*side*side;
        }
    bool compareVolume(Cube aCube) {
        return volume() > aCube.volume();
    }
};
int main()
{
    Cube aCube();
    if (aCube.compareVolume()) {
        std::cout << "aCube larger than 50" << std::endl;
    } else {
        std::cout << "aCube smaller than 50" << std::endl;
    }
    return ;
}

final

禁止在派生类中重写某个函数成员；禁止将某个类作为基类。

class Carton ： public Box  {

    public ：
        double volume() const override final {
            /*codes*/
        }
}

friend

友元：友元函数，友元类

class中的元素都是，对象拥有的属性；友元跳出了这个限制，可以在外部描述这个对象，说这个对象拥有的属性，归根到底友元是描述对象的，所以放在类内部

声明也是合理的。

mutable

即使对象是const， name成员也可以被修改。

namespace

声明名称空间【名称空间中不应该包含函数main()， 运行库函数希望 main() 在全局名称空间中定义】

namespace myRegion {
    /*name space*/
}

#include <iostream>

void fun() {
    std::cout << "no space" << std::endl;
}

namespace space1 {
    void fun() {
        std::cout << "space 1" << std::endl;
    }
}

namespace space2 {
    void fun() {
        std::cout << "space 2" << std::endl;
    }

    void test() {
        ::fun();    //在名称空间中访问全局名称空间的重名函数
    }
}

int main()
{
    space2::test();
}

new

分配内存

noexcept

表示函数不会抛出异常【当noexcept修饰的函数抛出异常时会直接导致函数调用std::terminate()终止】

void excpt_func() noexcept;
void excpt_func() noexcept (常量表达式);

override

如果基类中没有一个相同名称的类成员，则标记为错误。

private, protected, public

访问指定符：

private，不能在类外部访问，不能被派生类的函数成员访问

protected，不能在类外部访问，可以被派生类函数成员访问

public，可以在类外部访问

static_cast

强制类型转换

static_cast<type_to_convert_to>(表达式)

template

定义一个模板

template <typename T, Type arg, ...> class ClassNamte
{
    ...
};

throw

抛出异常；后边不加参数时表示重新抛出当前的异常；

try {
    throw “test”;
}
catch （const char* message） {
    /*...*/
}

this

在执行任何类函数成员时，该函数都会自动包含一个隐藏的指针，成为this，该指针包含了调用该函数的对象的地址。

当上边函数不加 double length = 10; 时,两个函数是相同的；

当加上之后，就不同了，说明函数访问变量时候有一个内在的访问顺序。

double Box::volume() {
//    double length = 10;
    return length*width*heigth;
}
double Box::volume() { 
    return this->length * this->width * this->heigth; 
}

typeid

检查指针或引用的动态类型

#include <iostream>
#include <typeinfo>

class Box {
    private :
        int aa;
    protected :
    public :
        virtual void test_fun(void) {};　//必须有虚函数
};
class Carton : public Box {
    private :
        int bb;
    protected :
    public :

};
class CerealPack : public Carton {
    private :
        int cc;
    protected :
    public :
};
void fun(Box& rbox)
{
    if (typeid(rbox) == typeid(Box)) {
        std::cout << "test 111"<< std::endl;
    }
    if (typeid(rbox) == typeid(Carton)) {
        std::cout << "test 222"<< std::endl;
    }
    if (typeid(rbox) == typeid(CerealPack)) {
        std::cout << "test 333"<< std::endl;
    }
    return ;
}
int main()
{
    Carton carton;
    CerealPack pack;
#if 1
    fun(dynamic_cast<Box&>(carton));
    fun(dynamic_cast<Box&>(pack));
#endif
    return ;
}

$ ./typeid    【没有虚函数时，全都输出  test 111】
test 222
test 333

using

using namespace_name::identifier;

virtual

虚函数，调用该函数时都是动态绑定；在基类中没有定义的函数称为纯虚函数。

class Shape {
    private :
    protected :
    public :
        virtual void draw() const = ;  /*=0表示没有定义，是一个纯虚函数*/
};