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表示没有定义，是一个纯虚函数*/

};

巴特西

c++ 中的符号与关键字

最新文章

热门文章