精华内容
下载资源
问答
  • 外部关键字

    2020-09-15 16:51:26
    extern:用在全局变量或函数的声明前,此处要注意变量有全局和局部之分,而函数无(函数内也不能再嵌套函数)。 static : 1,在局部中时的数据延长使用,在.data区。 2,在全局区,该static的可见性只在本文件下...
      extern:用在全局变量或函数的声明前,此处要注意变量有全局和局部之分,而函数无(函数内也不能再嵌套函数)。
    

    static : 1,在局部中时的数据延长使用,在.data区。
    2,在全局区,该static的可见性只在本文件下有效,且该部分只在当前文件下有效。其他无效,在.data区。
    3,函数前加static,该函数只有当前文件可用,其他文件仍然不可调用。即便有extern
    cons:无论写在类型前还是类型后意义等价,const和类型结合;拿const修饰必须给予初始化。
    “*”:int *p,s;当我们定义指针时,*和我们的变量名结合,所以此处s不是指针变量。

    展开全文
  • gcc __attribute__关键字举例之visibility

    千次阅读 2015-06-24 14:33:10
    g++在编译时,可用参数-fvisibility指定所有符号的可见性(不加此参数时默认外部可见,参考man g++中-fvisibility部分);若需要对特定函数的可见性进行设置,需在代码中使用__attribute__设置visibility属性。

    visibility用于设置动态链接库中函数的可见性,将变量或函数设置为hidden,则该符号仅在本so中可见,在其他库中则不可见。

    g++在编译时,可用参数-fvisibility指定所有符号的可见性(不加此参数时默认外部可见,参考man g++-fvisibility部分);若需要对特定函数的可见性进行设置,需在代码中使用__attribute__设置visibility性。

     编写大型程序时,可用-fvisibility=hidden设置符号默认隐藏,针对特定变量和函数,在代码中使用__attribute__((visibility("default")))令该符号外部可见,这种方法可用有效避免so之间的符号冲突。


    //.cpp

    __attribute ((visibility("default"))) int engine_init(config_ *cfg)

    {}


    //makefile 

    CC = g++
    CFLAGS += -Wall -Werror ${HDTCL} -fPIC  -fvisibility=hidden


    结果是:

    engine_init接口外部可见,其他没有添加__attribute ((visibility("default")))说明的接口外部不可见。





    展开全文
  • Dockerfile关键字介绍以及Dockerfile举例

    Dockerfile 关键字

    关键字 作用 备注
    FROM 指定父镜像 指定dockerfile基于那个image构建
    MAINTAINER 作者信息 用来标明这个dockerfile谁写的
    LABEL 标签 用来标明dockerfile的标签 可以使用Label代替Maintainer 最终都是在docker image基本信息中可以查看
    RUN 执行命令 执行一段命令 默认是/bin/sh 格式: RUN command 或者 RUN [“command” , “param1”,“param2”]
    CMD 容器启动命令 提供启动容器时候的默认命令 和ENTRYPOINT配合使用.格式 CMD command param1 param2 或者 CMD [“command” , “param1”,“param2”]
    ENTRYPOINT 入口 一般在制作一些执行就关闭的容器中会使用
    COPY 复制文件 build的时候复制文件到image中
    ADD 添加文件 build的时候添加文件到image中 不仅仅局限于当前build上下文 可以来源于远程服务
    ENV 环境变量 指定build时候的环境变量 可以在启动的容器的时候 通过-e覆盖 格式ENV name=value
    ARG 构建参数 构建参数 只在构建的时候使用的参数 如果有ENV 那么ENV的相同名字的值始终覆盖arg的参数
    VOLUME 定义外部可以挂载的数据卷 指定build的image那些目录可以启动的时候挂载到文件系统中 启动容器的时候使用 -v 绑定 格式 VOLUME [“目录”]
    EXPOSE 暴露端口 定义容器运行的时候监听的端口 启动容器的使用-p来绑定暴露端口 格式: EXPOSE 8080 或者 EXPOSE 8080/udp
    WORKDIR 工作目录 指定容器内部的工作目录 如果没有创建则自动创建 如果指定/ 使用的是绝对地址 如果不是/开头那么是在上一条workdir的路径的相对路径
    USER 指定执行用户 指定build或者启动的时候 用户 在RUN CMD ENTRYPONT执行的时候的用户
    HEALTHCHECK 健康检查 指定监测当前容器的健康监测的命令 基本上没用 因为很多时候 应用本身有健康监测机制
    ONBUILD 触发器 当存在ONBUILD关键字的镜像作为基础镜像的时候 当执行FROM完成之后 会执行 ONBUILD的命令 但是不影响当前镜像 用处也不怎么大
    STOPSIGNAL 发送信号量到宿主机 该STOPSIGNAL指令设置将发送到容器的系统调用信号以退出。
    SHELL 指定执行脚本的shell 指定RUN CMD ENTRYPOINT 执行命令的时候 使用的shell

    Dockerfile举例

    FROM centos:7
    LABEL maintainer blackholll@163.com
    # 安装基础包
    RUN yum install -y mysql-devel gcc gcc-devel python3 python3-pip python3-dev python3-devel mysql-devel zlib-devel openssl-devel openssl-devel git
    RUN mkdir -p /var/log/loonflow
    WORKDIR /opt
    # RUN git clone https://github.com/blackholll/loonflow.git
    RUN git clone https://gitee.com/shihowcom/loonflow_ro
    WORKDIR /opt/loonflow_ro
    RUN git checkout r1.0.6
    WORKDIR /opt
    RUN mv loonflow_ro loonflow
    WORKDIR /opt/loonflow/requirements
    RUN pip3 install -r pro.txt -i http://pypi.douban.com/simple/ --trusted-host=pypi.douban.com
    # 复制config.py文件
    WORKDIR /opt/loonflow/settings
    RUN cp pro.py.simple config.py
    # 修改redis配置
    RUN sed -i "s/REDIS_HOST = '127.0.0.1'/REDIS_HOST = 'loonflow-redis'/g" /opt/loonflow/settings/config.py
    RUN sed -i "s/REDIS_PASSWORD = ''/REDIS_PASSWORD = 'loonflow123'/g" /opt/loonflow/settings/config.py
    
    # 修改数据库配置
    RUN sed -i "s/'NAME': 'loonflownew'/'NAME': 'loonflow'/g" /opt/loonflow/settings/config.py
    RUN sed -i "s/'USER': 'loonflownew'/'USER': 'loonflow'/g" /opt/loonflow/settings/config.py
    RUN sed -i "s/'PASSWORD': '123456'/'PASSWORD': 'loonflow123,.Ly'/g" /opt/loonflow/settings/config.py
    RUN sed -i "s/'HOST': '127.0.0.1'/'HOST': 'loonflow-db'/g" /opt/loonflow/settings/config.py
    
    # 修改日志路径
    RUN sed -i "/HOMEPATH = os.environ/c\    HOMEPATH = '/var/log/loonflow'" /opt/loonflow/settings/common.py
    
    WORKDIR /opt/loonflow
    
    展开全文
  • C++关键字汇总并举例

    2020-06-19 17:13:40
    c++中依然支持register关键字,但是c++编译器也有自己的优化方式,即某些变量不用register关键字进行修饰,编译器也会将多次连续使用的变量优化放入寄存器中,例如入for循环的循环变量i。 c++中也可以对register...
    1. asm
      用于在C++源码中内嵌汇编语言。
       __asm mov al, 2
       __asm mov dx, 0xD007
       __asm out al, dx
    
    1. do
      配合while使用
    	do
    	{
    	...
    	}while(1)
    
    1. if
      判断
     	if(){
     	...
     	}else{
     	...
     	}
    
    1. return
      返回
     	return 1;
    
    1. try
      异常处理,激活异常
    	 try
    	 {
    	 ...
    	 }catch(异常){
    	 ...
    	 }
    
    1. auto
      存储类型标识符
    	  int a = 10;
    	  auto b = a;
    
    1. double
      双精度类型,一般占8个字节
    	 double a;
    
    1. inline
      内联函数的定义将在编译时在调用处展开。inline 函数一 般由短小的语句组成,可以提高程序效率。 不管大小程序加上就好了,别的交给编译器。
    	 inline int fuc(){
    	 		return 1;
    	 }
    
    1. short
      短整型。一般占2个字节
    	short a;
    
    1. typedef
      类型定义
    	typedef 类型 定义名;
    
    1. bool
      布尔类型,可选true,false,在c++里可与Int混用。一般占1个字节
    	 bool a = true;
    
    1. dynamic_cast
      动态转换,dynamic_cast是四个强制类型转换操作符中最特殊的一个(static_cast、dynamic_cast、const_cast、reinterpret_cast),它支持运行时识别指针或引用。允许在运行时刻进行类型转换,从而使程序能够在一个类层次结构安全地转换类型。dynamic_cast 提供了两种转换方式,把基类指针转换成派生类指针,或者把指向基类的左值转换成派生类的引用。
     //这是第一种情况
        Base* base = new Derived;
        if(Derived *der= dynamic_cast<Derived*>(base))
        {
            cout<<"第一种情况转换成功"<<endl;
        }
        //这是第二种情况
        Base * base1 = new Base;
        if(Derived *der1 = dynamic_cast<Derived*>(base1))
        {
            cout<<"第二种情况转换成功"<<endl;
        }
        else 
        {
            cout<<"第二种情况转换失败"<<endl;
        }
    
    1. int
      整型。一般占4个字节。
     	int a;
    
    1. signed
      有符号,表明该类型是有符号数,和 unsigned 相反。也就是第一个位代表正负,剩余的代表大小。数字类型(整型和浮点型)都可以用 signed 修饰。但默认就是 signed,所以一般不会显式使用。 例如:signed int 大小区间为-128-127,int a = 1,其二进制就是0000000000000001。
      	signed int a;
    
    1. typeid
      指出指针或引用指向的对象的实际派生类型
    	short a;
    	cout<<typeid(a).name()<<endl;
    	输出:
    	short
    
    1. break
      中断、跳出。用在switch语句或者循环语句中。程序遇到 break 后,即跳过该程序段,继续后面的语句执行。
    	 while(1){
    	 	if(1 == a)
    	 		break;
    	 }
    
    1. else
      else 紧跟在 if 后面,用于对 if 不成立的情况的选择。
    	 if(1 == a)
    	 {
    	 	...
    	 }else{
    	 	...
    	 }
    
    1. long
      长整型。一般占4个字节
    2. long long
      长长整型。一般占8个字节
    3. static
      静态的。静态变量作用范围在一个文件内,程序开始时分配空间,结束时释放空间,默认初始化为 0,使用时可改变其值。静态变量或静态函数,只有本文件内的代码才可访问它,它的名字(变量名或函数名)在其它文件中不可见。因此也称为"文件作用域"。在 C++ 类的成员变量被声明为 static(称为静态成员变量),意味着它被该类的所有实例所共享,也就是说当某个类的实例修改了该静态成员变量,其修改值为该类的其它所有实例所见;而类的静态成员函数也只能访问静态成员(变量或函数)。类的静态成员变量必须在声明它的文件范围内进行初始化才能使用,private 类型的也不例外。 static的值必须定义。
    	static int i = 1;
    
    1. union
      联合,类似于 enum。不同的是 enum 实质上是 int 类型的,而 union 可以用于所有类型,并且其占用空间是随着实际类型大小变化的。
    	union test
    	{
    	     char mark;
    	     long num;
    	     float score;
    	};
    
    1. case
      用于 switch 语句中,用于不同的条件类型判断。
    	switch(a){
    		case 1:
    		...
    		break;
    	}
    
    1. enum
      枚举类型,给出一系列固定的值。序号从0开始
     enum <类型名> {<枚举常量表>};
     enum color_set1 {RED, BLUE, WHITE, BLACK};
    //apple=0,orange=1,banana=1,peach=2,grape=3
     enum fruit_set {apple, orange, banana=1, peach, grape}
     //Sun,Mon,Tue,Wed,Thu,Fri,Sat的值分别为7、1、2、3、4、5、6
     enum week {Sun=7, Mon=1, Tue, Wed, Thu, Fri, Sat};
    
    1. mutable(不常用)
      易变的。只能用于类的非静态和非常量数据成员,跟constant(既C++中的const)是反义词。在C++中,mutable也是为了突破const的限制而设置的。被mutable修饰的变量,将永远处于可变的状态,即使在一个const函数中。
    	class CTest{
    	 	public:
    	 	int getNum() const;
    	 	private:
    	 	mutable int m_nums;
    	};
    	int CTest:getNum() const
    	{
    	    m_nums++;
    	    return 0;
    	}
    
    1. static_cast
      强制转换之一。该运算符把 expression 转换为 type-id 类型,但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法:
    ① 用于类层次结构中基类和子类之间指针或引用的转换。进行上行转换(把子类的指针或引用转换成基类表示)是安全的;进行下行转换(把基类指针或引用转换成子类表示)时,由于没有动态类型检查,所以是不安全的。
    ② 用于基本数据类型之间的转换,如把 int 转换成 char,把 int 转换成 enum。这种转换的安全性也要开发人员来保证。
    ③ 把空指针转换成目标类型的空指针。
    ④ 把任何类型的表达式转换成void类? 
    

    注意 static_cast 不能转换掉 expression 的 const、volitale、或者 __unaligned 属性。
    用法:

    	static_cast < type-id > ( expression ) 
    
    1. unsigned
      无符号。与signed相反。
    	 unsigned int a;
    
    1. catch
      捕捉异常。
    	 try{
    	 	...
    	 }catch{
    	 	...
    	 }
    
    1. explicit
      显式的.其作用是"禁止单参数构造函数"被用于自动型别转换,其中比较典型的例子就是容器类型。在这种类型的构造函数中你可以将初始长度作为参数传递给构造函数。
    class CxString  // 没有使用explicit关键字的类声明, 即默认为隐式声明  
    {  
    public:  
        CxString(int size)  
        {  
            ...
        }  
    };  
    CxString string2 = 10;    // 这样是OK的, 为CxString预分配10字节的大小的内存
    //--------------------------------------------------------
     class CxString  // 使用关键字explicit的类声明, 显示转换  
    {  
    public:  
        explicit CxString(int size)  
        {  
           ...
        }  
    };  
    CxString string2 = 10;    // 这样是不行的, 因为explicit关键字取消了隐式转换
    
    1. namespace
      命名空间。用于在逻辑上组织类,是一种比类大的结构。适合多人协同开发,避免命名冲突。
     namespace sella {
    	namespace variant {
    		class String;
    	}
    }
    
    1. struct
      结构体类型,类似于 class 关键字,与 C 语言兼容(class 关键字是不与 C 语言兼容的),可以实现面向对象程序设计。 莫太纠结与class的区别,别人创建c++的时候是为了兼容C语言,兼容struct!!!
    struct xx{
     	...
     }xxx;
    
    1. using
      使用空间。
     using namespace std;
    
    1. char
      字符类型。占1个字节
    	char a = 'a';
    
    1. export
      为了访问其他编译单元(如另一代码文件)中的变量或对象,对普通类型(包括基本数据类、结构和类),可以利用关键字extern,来使用这些变量或对象时;但是对模板类型,则必须在定义这些模板类对象和模板函数时,使用标准C++新增加的关键字export(导出/出口/输出)。
    extern int n;
    extern struct Point p;
    extern class A a;
    export template<class T> class Stack<int> s;
    export template<class T> void f (T& t) {……}
    
    // out.h:(声明头文件——只包含out函数的声明信息)
    template<class T> void out (const T& t);
    
    // out.cpp:(定义代码文件——包含out函数的声明[通过include]和定义等全部信息)
    #include <iostream>
    #include “out.h”
    export template<class T> void out (const T& t) {std::cerr << t;}
    
    1. new
      创建一个对象。new 运算符总是返回一个指针。与delete对应。
     int* pTest = new int();
    
    1. switch
      switch(转换)类似于 if-else-if 语句,是一种多分枝语句。它提供了一种简洁的书写,并且能够生成效率更好的代码。但是,switch 后面的判断只能是int(char也可以,但char本质上也是一种int类型)。switch 语句最后的 default 分支是可选的。
    	switch(a){
    	 	case 1:
    	 	....
    	 	break;
    	 	default:
    	 	....
    	 	break;
    	}
    
    1. virtual
      虚的,用来实现多态之一(虚函数和引用)。
     class CTest{
     public:
     		CTest();
     		 virtual ~CTest();
     public:
     		virtual void getTest();
     };
    
    1. class
      类。使用 class 关键字声明一个类。 如果不带public等默认private
      class XXX{

      };
    2. extern
      外部的。声明变量或函数为外部链接,即该变量或函数名在其它文件中可见。被其修饰的变量(外部变量)是静态分配空间的,即程序开始时分配,结束时释放。用其声明的变量或函数应该在别的文件或同一文件的其它地方定义(实现)。在文件内声明一个变量或函数默认为可被外部使用。在 C++ 中,还可用来指定使用另一语言进行链接,这时需要与特定的转换符一起使用。目前仅支持 C 转换标记,来支持 C 编译器链接。使用这种情况有两种形式:
    	extern int n;
     
     	extern "C" 声明语句
     	extern "C" { 声明语句块 }
    
    1. register
      寄存器。声明的变量称着寄存器变量,在可能的情况下会直接存放在机器的寄存器中;但对 32 位编译器不起作用,当 global optimizations(全局优化)开的时候,它会做出选择是否放在自己的寄存器中;不过其它与 register 关键字有关的其它符号都对32位编译器有效。
      在早期c语言编译器不会对代码进行优化,因此使用register关键字修饰变量是很好的补充,大大提高的速度。
      register关键字请求让编译器将变量a直接放入寄存器里面,以提高读取速度,在C语言中register关键字修饰的变量不可以被取地址,但是c++中进行了优化。
      c++中依然支持register关键字,但是c++编译器也有自己的优化方式,即某些变量不用register关键字进行修饰,编译器也会将多次连续使用的变量优化放入寄存器中,例如入for循环的循环变量i。
      c++中也可以对register修饰的变量取地址,不过c++编译器发现程序中需要取register关键字修饰的变量的地址时,register关键字的声明将变得无效。
      1.被register修饰的变量必须是CPU能够接受的类型,因为有的机器识别不了浮点型,所以register变量的长度应该小于等于整形,但现在有的机器是可以使用浮点型的register变量的。
      2.在C语言中,一旦声明为寄存器变量,由于可能会保存到寄存器中,编译器是不允许对其取地址(&)的。
      3.只有局部自动变量和形参可以是寄存器变量,比如在C语言中,全局变量是不能用register修饰的,并且局部静态变量也不能用register修饰。
      4.register变量的个数是有限的,因为一个CPU只有那么多个寄存器,并且类型也会受到CPU的限制,并且某些寄存器只能接受特定的类型,如指针类型。
      而在C++中,该关键字又有几点不同:
      1.register 关键字无法在全局中定义变量,否则会被提示为寄存器无效。其实这一点在新的gcc编译器下C语言也不允许定义全局的register变量,因为生命周期直到程序结束,期间都作为寄存器变量的话明显不妥。
      2.register 关键字在局部作用域中声明时,可以用 & 操作符取地址,一旦使用了取地址操作符,被定义的变量会强制存放在内存中。
    1未使用寄存器组
    	for(int i=0;i<100000;i++){
            for(int j=0;j<i;j++){
                a+=i;
                a-=i;
            }
            a+=i;
        } //用时14.64秒
    2使用寄存器组
    	for(register int i=0;i<100000;i++){
            for(register int j=0;j<i;j++){
                a+=i;
                a-=i;
            }
            a+=i;
        } //用时2.954秒
    
    1. sizeof
      获取字节数。由于 C++ 每种类型的大小都是由编译器自行决定的,为了增加可移植性,可以用 sizeof 运算符获得该数据类型占用的字节数。
    	int a = 1;
    	cout<<sizeof(a)<<endl;
    
    1. typename
      typename(类型名字)关键字告诉编译器把一个特殊的名字解释成一个类型。在下列情况下必须对一个 name 使用 typename 关键字:
      1. 一个唯一的name(可以作为类型理解),它嵌套在另一个类型中的。
      2. 依赖于一个模板参数,就是说:模板参数在某种程度上包含这个name。当模板参数使编译器在指认一个类型时产生了误解。
      typename在下面情况下禁止使用:
      1.模板定义之外,即typename只能用于模板的定义中
      2.非限定类型,比如int,vector之类
      3.基类列表中,比如template class C1 : T::InnerType不能在T::InnerType前面加typename
      4.构造函数的初始化列表中
    	template <typename T>
    	int compare(const T &v1, const T &v2)
    	{
    	    .....
    	    return 0;
    	}
    //------------------------------------
    	template <class T>
        void foo() {
            typename T::iterator * iter;
            // ...
        }
    
    1. const
      常量的。所修饰的对象或变量不能被改变,修饰函数时,该函数不能改变在该函数外面声明的变量也不能调用任何非const函数。在函数的声明与定义时都要加上const,放在函数参数列表的最后一个括号后。
      在 C++ 中,用 const 声明一个变量,意味着该变量就是一个带类型的常量,可以代替 #define,且比 #define 多一个类型信息,且它执行内链接,可放在头文件中声明;但在 C 中,其声明则必须放在源文件(即 .C 文件)中,在 C 中 const 声明一个变量,除了不能改变其值外,它仍是一具变量。
     	const double pi(3.14159);const double pi = 3.14159;
    
    1. false
      假的。boot类型值之一,与int的0值等同。
     	bool tmp = false;
    
    1. operator
      操作符重载。
    bool operator==(const String &other) const throw ();
    bool operator!=(const String &other) const throw ();
    bool operator>(const String &other) const throw ();
    bool operator<(const String &other) const throw ();
    String& operator=(const String &other) throw ();
    String& operator=(String &&other) throw ();
    String& operator=(const std::string &other) throw ();
    String& operator=(const char *other) throw ();
    String& operator+=(const std::string &value) throw ();
    
    1. template
      模板。泛型编程。
    template <typename T>
    struct check
    {
       static_assert(sizeof(int) <= sizeof(T), "not big enough");
    };
    
    1. void
      空,可以作为函数返回值,表明不返回任何数据;可以作为参数,表明没有参数传入(C++中不是必须的);可以作为指针使用。
     void fuc(){
    	.....
     }
    
    1. const_cast
      该运算符用来修改类型的 const 或 volatile 属性。除了 const 或 volatile 修饰之外, type_id 和 expression 的类型是一样的。常量指针被转化成非常量指针,并且仍然指向原来的对象;常量引用被转换成非常量引用,并且仍然指向原来的对象;常量对象被转换成非常量对象。
    	const_cast<type_id> (expression)
    
    1. float
      浮点型。占4个字节
    	float a = 1.12;
    
    1. private
      私有。访问控制符。被标明为 private 的字段只能在本类以及友元中访问。
    	class CTest{
    	 	private:
    	 		int m_a;
    	};
    
    1. this
      自身的指针。编译器在程序背后做的事,会在函数第一个参数的位置会插入。
     void setNum(int num){
     		m_Num = num ;
    }
    
    1. volatile
      volatile提醒编译器它后面所定义的变量随时都有可能改变,因此编译后的程序每次需要存储或读取这个变量的时候,都会直接从变量地址中读取数据。如果没有volatile关键字,则编译器可能优化读取和存储,可能暂时使用寄存器中的值,如果这个变量由别的程序更新了的话,将出现不一致的现象。
    int flag;
    void main()
    {
    	test1();
    	while(0 == flag){
    		...
    	}
    	test2();
    }
    

    这段程序等待内存变量flag的值变为1(怀疑此处是0,有点疑问,)之后才运行test2()。变量flag的值由别的程序更改,这个程序可能是某个硬件中断服务程序。例如:如果某个按钮按下的话,就会对DSP产生中断,在按键中断程序中修改flag为1,这样上面的程序就能够得以继续运行。但是,编译器并不知道flag的值会被别的程序修改,因此在它进行优化的时候,可能会把flag的值先读入某个寄存器,然后等待那个寄存器变为1。如果不幸进行了这样的优化,那么while循环就变成了死循环,因为寄存器的内容不可能被中断服务程序修改。为了让程序每次都读取真正flag变量的值,定义如下:

    volatile int flag;
    
    1. continue
    2. for
    3. protected
    4. throw
      抛出异常
     if( b == 0 )
     {
          throw "Division by zero condition!";
     }
    
    1. wchar_t
      wchar_t占两个字节
    2. default
      明确默认的函数声明式一种新的函数声明方式,在C++11发布时做出了更新。C++11允许添加“=default”说明符到函数声明的末尾,以将该函数声明为显示默认构造函数。这就使得编译器为显示默认函数生成了默认实现,它比手动编程函数更加有效。
      每当我们声明一个有参构造函数时,编译器就不会创建默认构造函数。在这种情况下,我们可以使用default说明符来创建默认说明符:
      // use of defaulted functions
      #include
      using namespace std;
    class A {
    public:
        A(int x){
            cout << "This is a parameterized constructor";
        }
        A() = default;
    };
    
    int main(){
        A a;          //call A()
        A x(1);       //call A(int x)
        cout<<endl;
        return 0;
    } 
    

    默认函数需要用于特殊的成员函数(默认构造函数,复制构造函数,析构函数等)
    有兴趣的可以参照下=delete
    62. friend
    友元。友元可以访问与其有 friend 关系的类中的 private/protected 成员,通过友元直接访问类中的 private/protected 成员的主要目的是提高效率。友元包括友元函数和友元类。
    63. public
    64. true
    65. while
    66. delete
    67. goto
    68. reinterpret_cast

    展开全文
  • c语言中static关键字用法详解

    万次阅读 多人点赞 2018-04-05 18:18:14
    static关键字在c语言中比较常用,使用恰当能够大大提高程序的模块化特性,有利于扩展和维护。 但是对于c语言初学者,static由于使用灵活,并不容易掌握。本文就static在c语言中的应用进行总结,供参考使用。错漏...
  • volatile关键字

    2016-11-17 22:53:54
    如果没有volatile关键字,则编译器可能优化读取和存储,可能暂时使用寄存器中的值,如果这个变量由别的程序更新了的话,将出现不一致的现象。下面举例说明。在DSP开发中,经常需要等待某个事件的触发,所以经常会写...
  • let关键字

    2020-11-23 20:46:26
    基本语法 和var关键字用法基本一致。 let a = 10; let fn = function () { console.log('hello') } ...var关键字会将变量挂载到window对象上,无块级作用域,有变量提升。...举例说明: for (var i =
  • Swift关键字总结上篇

    千次阅读 2017-12-24 20:41:13
    Swift 中有多少关键字? 在Swift官方文档的词汇结构中, 有非常多的关键字, 它们被用于声明中、语句中、表达式中、类中、模式中, 还有以数字符号#开头的关键字, 以及特定上下文环境使用的关键字。 本文中涉及的代码...
  • Swift关键字总结下篇

    千次阅读 2017-12-29 10:35:01
    Swift 中有多少关键字? 在Swift官方文档的词汇结构中, 有非常多的关键字, 它们被用于声明中、语句中、表达式中、类中、模式中, 还有以数字符号#开头的关键字, 以及特定上下文环境使用的关键字。本文中涉及的代码...
  • extern关键字

    2014-11-20 18:39:04
    ,可以在整个程序的任何地方被使用,举例说,如果A文件中定义了某全局变量,那么B文件中应可以使用该变量。修改我们的程序,加以验证: 1 2 3 4 5 6 7 ...
  • 关键字volatile

    2015-08-13 19:32:26
    如果没有volatile关键字,则编译器可能优化读取和存储,可能暂时使用寄存器中的值,如果这个变量由别的程序更新了的话,将出现不一致的现象。下面举例说明。在DSP开发中,经常需要等待某个事件的触发,所以经常会写...
  • C++extern关键字

    2021-02-28 17:36:39
    extern 关键字用于使用外部文件定义的变量; 该变量特点: 1、需为全局变量; 2、在引用时只需要指明类型以及变量名即可,不需要重新赋值。 3、不需要改该变量被虚构可以用const关键字修饰; 4、用include将另一个...
  • volitale关键字

    2013-09-04 12:46:35
    如果没有volatile关键字,则编译器可能优化读取和存储,可能暂时使用寄存器中的值,如果这个变量由别的程序更新了的话,将出现不一致的现象。 下面举例说明。在DSP开发中,经常需要等待某个事件的触发,所以经常...
  • C语言中关键字

    2019-03-03 00:06:24
    关键字1、Volatile关键字有什么含意 并给出三个不同的例子? 一个定义为volatile的变量说明这变量可能会被改变,这样编译器不会对这个变量作优化。精确地说就是,优化器在用到这个变量时必须每次都小心地重新读取这...
  • C语言关键字

    千次阅读 2016-04-19 11:14:44
    auto被解释为一个自动存储变量的关键字,也就是申明一块临时的变量内存。auto int a=4;表示a为一个自动存储的临时变量。 作用:C程序是面向过程的,在C代码中会出现大量的函数模块,每个函数都有其生命周期(也称...
  • C语言关键字volatile

    2017-04-26 20:41:59
    volatile提醒编译器它后面所定义的变量随时都有可能改变,因此编译后的程序每次需要存储或读取这个变量的时候...如果没有volatile关键字,则编译器可能优化读取和存储,可能暂时使用寄存器中的值,如果这个变
  • static关键字

    2013-06-01 07:10:55
    像在VB,C,C++,Java中我们可以看到static作为关键字和函数出现,在其他的高级计算机语言如FORTRAN、ALGOL、COBOL、BASIC、LISP、SNOBOL、PL/1、Pascal、PROLOG、Ada等语言中也是有出现的,只是有着不同的作用,...
  • C#关键字详解

    千次阅读 2013-03-11 14:18:00
    关键字是对编译器有特殊意义的预定义的保留标识符。 它们不能在程序中用作普通标识符,除非在它们前面加上@前缀。    第一部分    一.访问关键字:base,this ~~~~base:访问基类的成员。 用于从派生类中...
  • extern 关键字

    千次阅读 2012-05-12 12:20:23
    1、 声明外部变量 现代编译器一般采用按文件编译的方式,因此在编译时,各个文件中定义的全局变量是 互相透明的,也就是说,在编译时,全局变量的可见域限制在文件内部。下面举一个简单的例子。创建一个工程,...
  • C++ explicit关键字

    2020-03-24 17:01:15
    1. 使用介绍 ...explicit关键字只能用于类内部的构造函数声明上,而不能用在类外部的函数定义(函数实现)上。 == explicit起作用的情况== ① 当构造函数只有一个参数时,会进行自动隐式转换; ② 当构...
  • java提供的关键字有50个,保留字2个 保留字:goto 、 const 这次学习static static关键字 使用场景: 修饰普通方法 主函数 除构造函数外的方法 /** * 主函数 * @param args */ public static void main...
  • 万字长文详细搞懂 volatile 关键字

    千次阅读 多人点赞 2021-05-19 09:21:26
    volatile 这个关键字大家都不陌生,这个关键字一般通常用于并发编程中,是 Java 虚拟机提供的轻量化同步机制,你可能知道 volatile 是干啥的,但是你未必能够清晰明了的知道 volatile 的实现机制,以及 volatile ...
  • C语言关键字Volatile

    2017-06-25 16:46:26
    如果没有volatile关键字,则编译器可能优化读取和存储,可能暂时使用寄存器中的值,如果这个变量由别的程序更新了的话,将出现不一致的现象。下面举例说明。在DSP开发中,经常需要等待某个事件的触发,所以经常会写...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,649
精华内容 16,659
关键字:

外部关键字举例