精华内容
下载资源
问答
  • C++编程之命名空间、const常量

    千次阅读 2020-03-01 23:04:16
    const增强 //1、C语言中,全局变量受到常量区的保护,即使语法通过,运行也会报错。如下代码。 const int m_A = 300; void test06() { //m_A = 400; // 不允许直接修改 int* p = &m_A; // 使用引用修改。语法通过...

    系列文章
    C++编程之引用的详细总结
    一文讲明白C++运算符重载


    1、C++命名空间

    • 解决命名冲突,保证数据一致性
    • 命名空间下可以放变量、函数、结构体、类等
    • 命名空间必须声明在全局的作用域下
    • 命名空间可以嵌套命名空间,示例如下:
    namespace Hero
    {
    	namespace LiBai
    	{...}
    	
       namespace HuangZhong
       {...}
    }
    
    • 命名空间是开放的,随时可以给其中添加新成员
    namespace B
    {
        int m_A = 100;
    }
    ...
    namespace B
    {
        int m_B = 200;
    }
    void test()
    {
        cout<<"B下的m_A="<<B::m_A<<endl;
        cout<<"B下的m_B="<<B::m_B<<endl;
    }
    //两处会合并在一起
    
    • 命名空间是可以匿名的
    namespace
    {
        int m_A = 200;
        int m_C = 300;
        //相当于在变量前面加了关键字static,类似于全局变量
        //static int m_A = 200;
        //static int m_C = 300;
    }
    
    void test()
    {
        cout<<m_A<<endl;
        cout<<::m_C<<endl;  //::前面如果没有任何作用域,代表了使用全局作用域
    }
    
    • 命名空间是可以起别名的
    namespace HeroNameVeryLongLong
    {
        string m_name = "赵云";
    }
    
    void test()
    {
        namespace heroName = HeroNameVeryLongLong;
        
        cout<<heroName::m_name<<endl;
        cout<<HeroNameVeryLongLong::m_name<<endl;
    }
    

    2、C++对C语言的增强

    • 全局变量检测增强
    #include<stdio.h>
    #include<stdlib.h>
    
    int a;
    int a = 10;
    
    
    int main()
    {
    	printf("%d \r\n", a); 
    	system("pause");
    	return 0;
    }
    // 上述两行变量a的代码,在C语言中是可以同时存在的。但在C++中不可以同时存在。
    
    • 函数检测增强【以下代码在C中可以正常运行】
    #include<stdio.h>
    #include<stdlib.h>
    
    // 1、声明函数返回值类型
    void GetNum1()
    {
    	return 10;
    }
    
    // 2、函数返回值增强,C中函数可以没有返回值,不报错,只有一个警告
    int GetAge()
    {
    	int a = 20;
    	printf("GetAge ..\r\n");
    }
    
    
    // 3、函数声明的返回值增强,在C中函数可以没有返回值
    GetNum()
    {
    	return 10;
    }
    
    // 4、函数检测增强,C中形参可以没有类型
    int GetS(w, h)
    {
    	return w*h;
    }
    
    
    void test1()
    {
    	///5、调用时,C对参数个数的检查也不严格,可以多传入参数。
    	GetS(10, 23, 45);
    }
    
    int main()
    {
    	int a = GetAge();	 
       system("pause");
    	return 0;
    }
    
    • 类型转换增强
    #include<stdio.h>
    #include<stdlib.h>
    
    // 类型转换增强,在C中可以隐式将void*转换为任意类型的指针,但是C++必须要显式转换,因此以下代码在C++中无法运行。
    void test03()
    {
    	char* p = malloc(sizeof(char)* 10);
    }
    
    int main()
    {
        test03();
    }
    
    • struct 的增强,C语言中struct中不可以放函数,只能有字段。但是C++中却可以存在函数。
    struct Person
    {
    	int age; 
    };
    
    void test04()
    {
        // 在C语言中,使用struct时,必须在声明的时候加struct。如果不加,可以使用typedef声明结构体。
        // 在C++中,声明的时候可以不加struct ,如 Person p2;
    	struct Person p1;
    	p1.age = 1;
    }
    
    • bool类型的增强,在C语言中是没有bool类型的。C++中bool类型表示真假,sizeof(bool)=1
    • 三目运算符的增强
    void test05()
    {
    	int a = 10;
    	int b = 20;
    	printf("%d", a > b ? a : b);
    
    	// 以下这行代码在C语言中无法通过
    	//a > b ? a : b = 100; 在C语言中,三目运算符返回的是值。相当于20=100;在C++中,三目运算符返回的是变量,即b=100;
     
    	// 当然在C语言下可以使用这种引用的方式让三目运算符返回引用。
    	*(a > b ? &a : &b) = 100;
    
    • const增强
    //1、C语言中,全局变量受到常量区的保护,即使语法通过,运行也会报错。如下代码。
    const int m_A = 300; 
    
    void test06()
    {
    	//m_A = 400;  // 不允许直接修改
    	int* p = &m_A; // 使用引用修改。语法通过
    	(*p) = 400;
    }
    
    // 2、C语言中,局部常量可以通过引用的方式修改值。局部常量被称为伪常量。
    void test07()
    {
    	const int m_B = 200;
        m_B=500; // 不允许
    	int* p = &m_B; // 允许
    	*p = 300;
       
        //int arr[m_intB]; 伪常量在C语言中是不能初始化数组的。
    }
    
    
    // 1、C++中,全局变量与C语言一样,也是无法修改值。引用或者直接修改都是不行的。
    // 2、C++中,局部变量也无法修改,原因是局部常量存储在符号表中,键值对存储,只读类型
    void test08()
    {
    	const int m_B = 200;
    
    	int* p = (int*)&m_B;  // 创建临时变量指向p,本体是不变的。
    	*p = 300;
     
        int arr[m_B];  //可以初始化数组。
    }
    
    //const在C语言中默认是外部链接属性
    //const在C++语言中默认是内部链接属性
    // 在外部文件textern_const.c中定义如下代码
    const int m_DDD = 100; // 默认在最前面加了extern
    
    // 在test.c中声明后直接使用。
    void test08()
    {
    	extern const int m_DDD;
    	printf("%d \r\n", m_DDD);
    }
    // C语言中是可以正常使用的,验证了const的外部链接属性。在C++中这样是无法运行的。
    
    //-------------------------------------------------------------
    // C++中,外部定义需要如下.
    extern const int m_A = 200; // 这样在其他文件中才会被访问到,extern提高作用域。
    
    

    3、const分配内存

    • 对const修饰的变量取地址的时候,会分配临时内存
    • const前加了extern后,也会分配内存。
    • 使用变量初始化const修饰的变量。
    #include<iostream>
    using namespace std;
    
    void test01()
    {
    	int a = 10;
    	//const int m_B = 30; // 直接初始化是常量,无法修改值,存储符号表中。
    
    	const int m_A = a;  //用变量初始化的常量,会分配内存,可以间接修改值。
    
    	int* p = (int*)&m_A;
    	*p = 40;
    
    	cout << m_A << endl;
    	cout << a << endl;
    }
    
    int main()
    {
    	test01();
    	system("pause");
    	return 0;
    }
    
    • 对于自定义的数据类型,也会分配内存。
    #include<iostream>
    using namespace std;
    #include<string>
    
    struct Person
    {
    	string name;
    	int age;
    };
    
    void test02()
    {
    	const Person p;
    
    	// 不能直接修改
    	/*p.name = "123";
    	p.age = 20;*/
    
    	Person* p1 = (Person*)&p;
    	p1->name = "12345";
    	p1->age = 23;
    
    	cout << p.age << endl;
    	cout << p.name << endl;
    }
    int main()
    {
    	test02();
    	return 0;
    }
    
    
    • const与#define的区别
      1、const有类型,可以进行编译类型安全检查,#define无类型。
      2、const有作用域,而#define不重视作用域,默认定义处到文件结尾,如果定义在指定作用域下有效的常量,那么#define不能用。

    注:以上是本次疫情期间学习某大神精心录制的视频以及阅读《C++ Primer Plus (第6版)》后总结的学习笔记,后续会继续更新学习笔记,记录学习成长点滴。
    原文来自我的有道云笔记

    展开全文
  • const常量与宏定义区别 1,转载地址: http://blog.sina.com.cn/s/blog_60d6fadc01012i52.html (1) 编译器处理方式不同  define宏...

    1,转载地址:

    http://blog.sina.com.cn/s/blog_60d6fadc01012i52.html

    (1) 编译器处理方式不同

      define宏是在预处理阶段展开。

      const常量是编译运行阶段使用。

    (2) 类型和安全检查不同

      define宏没有类型,不做任何类型检查,仅仅是展开。

      const常量有具体的类型,在编译阶段会执行类型检查。

    (3) 存储方式不同

      define宏仅仅是展开,有多少地方使用,就展开多少次,不会分配内存。

      const常量会在内存中分配(可以是堆中也可以是栈中)。

     

    (4)const  可以节省空间,避免不必要的内存分配。 例如:  
            #define PI 3.14159 //常量宏  
            const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ......  
            double i=Pi; //此时为Pi分配内存,以后不再分配!  
            double I=PI; //编译期间进行宏替换,分配内存  
            double j=Pi; //没有内存分配  
            double J=PI; //再进行宏替换,又一次分配内存!  
            const定义常量从汇编的角度来看,只是给出了对应的内存地址,而不是象#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝,而 #define定义的常量在内存中有若干个拷贝。 
    (5) 提高了效率。 编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高。

     

    const 与 #define的比较

        C++ 语言可以用const来定义常量,也可以用 #define来定义常量。但是前者比后者有更多的优点:

    (1)   const常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会产生意料不到的错误(边际效应)。

    (2)   有些集成化的调试工具可以对const常量进行调试,但是不能对宏常量进行调试。

     

    l  【规则5-2-1在C++ 程序中只使用const常量而不使用宏常量,即const常量完全取代宏常量。

    5.3 常量定义规则

    l  【规则5-3-1需要对外公开的常量放在头文件中,不需要对外公开的常量放在定义文件的头部。为便于管理,可以把不同模块的常量集中存放在一个公共的头文件中。

    l  【规则5-3-2如果某一常量与其它常量密切相关,应在定义中包含这种关系,而不应给出一些孤立的值。

    例如:

    const  float   RADIUS = 100;

    const  float   DIAMETER = RADIUS * 2;

    5.4 类中的常量

    有时我们希望某些常量只在类中有效。由于#define定义的宏常量是全局的,不能达到目的,于是想当然地觉得应该用const修饰数据成员来实现。const数据成员的确是存在的,但其含义却不是我们所期望的。const数据成员只在某个对象生存期内是常量,而对于整个类而言却是可变的,因为类可以创建多个对象,不同的对象其const数据成员的值可以不同。

        不能在类声明中初始化const数据成员。以下用法是错误的,因为类的对象未被创建时,编译器不知道SIZE的值是什么。

        class A

        {…

            const int SIZE = 100; // 错误,企图在类声明中初始化const数据成员

            int array[SIZE];       // 错误,未知的SIZE

        };

     

    const数据成员的初始化只能在类构造函数的初始化表中进行,例如

        class A

        {…

            A(int size);       // 构造函数

            const int SIZE ;  

        };

        A::A(int size) : SIZE(size) // 构造函数的初始化表

        {

          …

        }

        A  a(100);  // 对象 a 的SIZE值为100

        A  b(200);  // 对象 b 的SIZE值为200

     

        怎样才能建立在整个类中都恒定的常量呢?别指望const数据成员了,应该用类中的枚举常量来实现。例如

        class A

        {…

            enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量

            int array1[SIZE1];

            int array2[SIZE2];

        };

        枚举常量不会占用对象的存储空间,它们在编译时被全部求值。枚举常量的缺点是:它的隐含数据类型是整数,其最大值有限,且不能表示浮点数(如PI=3.14159)。sizeof(A) = 1200;其中枚举不占空间。

                             enum   EM { SIZE1 = 100, SIZE2 = 200}; // 枚举常量    sizeof(EM) = 4;


    展开全文
  • const常量存放的位置

    千次阅读 2019-10-14 11:57:16
    C语言中,用const定义的常量其实是值不能修改的变量,因此会给它分配存储空间;但是在C++中,const定义的常量要具体情况具体对待:对于基本数据类型的常量,编译器会把它放到符号表中而不分配存储空间,而ADT/UDT的...

    C语言中,用const定义的常量其实是值不能修改的变量,因此会给它分配存储空间;但是在C++中,const定义的常量要具体情况具体对待:对于基本数据类型的常量,编译器会把它放到符号表中而不分配存储空间,而ADT/UDT的const对象则需要分配存储空间(大对象)。还有一些情况下也需要分配存储空间,例如强制声明为extern的符号常量或取符号常量的地址等操作。

    展开全文
  • C++ const 常量

    千次阅读 2016-12-16 10:21:17
    const 常量  定义义后就不能被修改,所以定义时必须初始化:const std::string hi = "hello!"; const 对象作用域 在全局作用域定义的非const对象在整个程序中都可以访问,默认为extern. [code1]const...

    const 常量 

    定义义后就不能被修改,所以定义时必须初始化:const std::string hi = "hello!";

    const 对象作用域

    • 在全局作用域定义的非const对象在整个程序中都可以访问,默认为extern. [code1]
    • const对象默认为文件的局部变量,要使const变量能够在其他的文件中访问,必须地指定它为extern. [code2]

    常量表达式

    • const expression是指值不会改变并且在编译过程就能得到计算结果的表达式
    • 一个对象(或表达式)是不是常量表达式由它的数据类型和初始值共同决定 [code4]
    • 字面值属于常量表达式
    • 用常量表达式初始化的const对象也是常量表达式.

    一些const在头文件中的定义

    • 如果const变量是用常量表达式初始化的,那么它应该在头文件中定义(原因类似C的宏#define)
    • 如果const变量不是用常量表达式初始化,那么它就不应该在头文件中定义该const变量应该在一个源文件中定义并初始化,应在头文件中为它添加extern声明,以使其能被多个文件共享

    引用

    • 不能定义引用类型的引用,但可以定义任何其他类型的引用.
    • 引用必须用与该引用同类型的对象初始化.
    • 必须在定义引用时进行初始化,初始化后可以赋值,但是不能修改引用的指向.

    const 引用

    • 指向const对象的引用
    • 普通引用不能绑定const对象
    • const引用则可以绑定到不同但相关的类型的对象或绑定到右值. [code3]
    • 非const引用只能绑定到与该引用同类型的对象. code[3]

    const和指针

    指向const对象的指针(const int *ptr)

    • 允许给 ptr 重新赋值,使其指向另一个 const 对象,但不能通过 ptr 修改其所指对象的值.
    • 不能使用 void* 指针保存 const 对象的地址,必须使用 const void* 
    • 允许把非 const 对象的地址赋给指向 const 对象的指针

    const指针

    • int  *const curErr.从右向左把上述定义语句读作“curErr 是指向 int 型对象的 const 指针”
    • 与任何 const 量一样,const 指针也必须在定义时初始化. 且初始化过后不能指向另外一个对象

    指向 const 对象的 const 指针 

    • const double pi = 3.14159;const double *const pi_ptr = &pi;
    • 既不能修改 pi_ptr 所指向对象的值,也不允许修改该指针的指向.
    • 从右向左阅读上述声明语句:“pi_ptr 首先是一个 const 指针,指向 double 类型的 const 对象”。

    typedef和指针

    • typedef string *pstring;const pstring cstr;==string *const cstr;
    • 声明 const pstring 时,const 修饰的是 pstring 的类型,这是一个指针。因此,该声明语句应该是把cstr 定义为指向 string 类型对象的 const 指针
    • const 限定符既可以放在类型前也可以放在类型后。string const s1; == const string s2; [Code5]

    const和成员函数

    • 将成员函数声明为常量double avg_price() const;
    • const 成员不能改变其所操作的对象的数据成员
    • const 必须同时出现在声明和定义中,若只出现在其中一处,就会出现一个编译时错误。
    • 从 const 成员函数返回 *this

      • 在普通的非 const 成员函数中,this 的类型是一个指向类类型的 const 指针,可以改变 this 所指向的值,但不能改变 this 所保存的地址。

      • 在 const 成员函数中,this 的类型是一个指向 const 类类型对象的 const 指针。既不能改变 this 所指向的对象,也不能改变 this 所保存的地址。

      • 不能从 const 成员函数返回指向类对象的普通引用。const 成员函数只能返回 *this 作为一个 const 引用。


    const与成员函数重载

    • Screen& display(std::ostream &os){ do_display(os); return *this; }
    • const Screen& display(std::ostream &os) const{ do_display(os); return *this; }

    const与迭代器

    • const_iterator:只能用于读取容器内的元素,但不能改变其值

    =====
    Code1.在全局作用域定义的非const对象

    1. // file_1.cc  
    2. int counter; // definition  
    3. // file_2.cc  
    4. extern int counter; // uses counter from file_1  
    5. ++counter;  
    6. // increments counter defined in file_1  

    Code2.在全局作用域定义的const对象

    1. // file_1.cc  
    2. // defines and initializes a const that is accessible to other files  
    3. extern const int bufSize = fcn();  
    4. // file_2.cc  
    5. extern const int bufSize; // uses bufSize from file_1,extern 标志着bufSize 是一个声明,所以没有初始化式  
    6. // uses bufSize defined in file_1  
    7. for (int index = 0; index != bufSize; ++index)  
    8. // ...  

    Code3.const引用则可以绑定到不同但相关的类型的对象或绑定到右值

    1. /*const 引用可以初始化为不同类型的对象或者初始化为右值,如字面值常量:*/  
    2. int i = 42;  
    3. // legal for const references only  
    4. const int &r = 42;  
    5. const int &r2 = r + i;  
    6.   
    7. /*同样的初始化对于非 const 引用却是不合法的,而且会导致编译时错误。其原因非常微妙,值得解释一下。 
    8. 观察将引用绑定到不同的类型时所发生的事情,最容易理解上述行为。假如我们编写*/  
    9. double dval = 3.14;  
    10. const int &ri = dval;  
    11.   
    12. /*编译器会把这些代码转换成如以下形式的编码:*/  
    13. int temp = dval;  
    14. const int &ri = temp;  
    15. // create temporary int from the double  
    16. // bind ri to that temporary  
    17.   
    18. /*如果 ri 不是 const,那么可以给 ri 赋一新值。这样做不会修改 dval,而是修改了 temp。期望对 ri 的赋值会修改 dval 的程序员会发现 dval 并没 
    19. 89有被修改。仅允许 const 引用绑定到需要临时使用的值完全避免了这个问题,因为 const 引用是只读的。*/  

    Code4. 一个对象(或表达式)是不是常量表达式由它的数据类型和初始值共同决定

    1. const int max_files = 20; // max_files是常量表达式   
    2. const int limit = max_files + 1; // limit是常量表达式   
    3. int staff_size = 27; // staff_size不是常量表达式   
    4. const int sz = get_size(); // sz不是常量表达式   
    5. /*尽管staff_size的初始值是个字面值常量,但由于它的数据类型只是一个普通int而非const int,所以它不属于常量表达式。另一方面,尽管sz本身是一个常量,但它的具体值直到运行时才能获取到,所以也不是常量表达式。*/  

    Code5.const 限定符既可以放在类型前也可以放在类型后

    1. string s;  
    2. typedef string *pstring;  
    3.   
    4. //下面三种声明是等价的  
    5. const pstring cstr1 = &s;   
    6. pstring const cstr2 = &s;   
    7. string *const cstr3 = &s;   

    From:http://blog.csdn.net/liufei_learning/article/details/21219963
    展开全文
  • 使用const常量定义pi求圆的周长和面积 编写程序,实现从键盘输入圆的半径 r,计算并输出圆的周长和面积。 注意:本题要求必须使用 const 常量定义PI,PI 为双精度小数,取 3.14159。 示例 输入 12 输出 周长: 75....
  • C++:const常量的存储位置

    千次阅读 2019-08-12 19:54:34
    前言: 今日看cpp的内存管理这块,偶然想到加关键字const修饰的变量位于哪块内存区?遂在网上一顿搜索和群里与大神交流,得出以下结论。 ...1、const修饰的量不是常量,仅仅是个只读量 ...
  • 宏常量和const常量

    千次阅读 2018-03-03 15:12:48
    宏常量和const常量 标签(空格分隔): C 双学位高级语言程序设计 C算术运算和表达式 宏常量 对于那些经常使用常量,为了防止多次使用后弄错,或者忘记这个常量的含义,所以需要定义宏常量,用字符代替常量 ...
  • const常量赋初值问题

    千次阅读 2019-07-14 19:57:48
    不知从什么时候开始,脑海中总有一个印象,const常量在赋初值时,必须是编译期间可见的值,比如曾经认为: const int cval = 5; 这样的初始化赋值才是正确的,如果使用一个变量或者调用函数给const常量赋初值,则...
  • 类里面怎么定义const常量 C++ 方法二:(正确,有缺陷) 使用enum; class Test {  enum { size = 100};  int array[size]; //…… }; 使用enum不会占用对象中的存储空间的,枚举常量在编译的时候被...
  • C++中能用const就不要用#defiine const限定该常量只能在当前文件模块中使用 const必须初始化,切不允许再修改
  • c语言----与const常量有关的内存分配

    千次阅读 2019-07-21 18:39:25
    1. const 是不是存放在常量区中??? 2. 全局变量与常量区的关系??? 3. 为什么指针可以改变局部const数组内容而不能改变其局部const的内容??? 基础知识: 1、栈区(stack)—由编译器自动分配释放,...
  • const常量与define宏定义的区别

    千次阅读 2016-10-27 15:19:03
    #define RADIUS 100; const float RADIUS = 100; (1) 编译器处理方式不同  define宏是在预处理阶段展开。... const常量是编译运行阶段使用。... const常量有具体的类型,在编译阶段会执行
  • const 常量

    2017-11-14 11:13:15
    const常量的定义和应用。
  • 结果是不能编译通过,如下 大致意思是常量size2是用变量temp定义的,...将char str2[size2]这句去掉是可以编译通过的,这说明const常量是可以通过变量初始化的。只是在初始化之后就不可以再修改了。 这些规则其...
  • 对于const常量定义在头文件的思考

    千次阅读 2017-08-01 20:47:23
    今天在看effective C++ title02 时,看到一句话:由于常量定义式通常被放在头文件中(以便被不同的源码含入)。感觉十分困惑,因为在我的印象中,变量是不能定义在头文件中的,会引起重复定义的错误。 c++primer...
  • 01 常量对象 如果不希望某个对象的值被改变,则定义该对象的时候可以在前面加const关键字 class CTest ...在类的成员函数后面可以加const关键字,则该成员函数成为常量成员函数。 在常量成...
  • 类中静态变量与const常量成员的初始化
  • 宏常量,宏替换,const常量

    千次阅读 2019-10-03 16:53:19
    (1)宏常量也称为符号常量,是指用一个标识符号来表示的常量,宏常量是由宏定义编译预处理命令来定义的,宏定义的一般形式:#define 标识符 字符...(2)const常量:使用宏常量的最大问题是,宏常量没有数据类型。...
  • 为什么用C语言中const常量定义数组大小会报错?

    千次阅读 热门讨论 2019-05-21 23:31:54
    1.为什么用C语言中const常量定义数组大小会报错? 在c语言编程中我们这样定义数组时编译器回报一个错误 const int maxn = 10; int a[maxn]; //C程序报错 //error:variably modified 'a' at file scope **注:**...
  • C++ 常量const

    万次阅读 多人点赞 2018-07-12 14:57:57
    文章概述 ...C++中使用const关键字来定义一个常量。 //a是常量 const int a=10; b. 对于常量,编译器会将其放在一个只读的内存区域,其值不能发生改变。 c. 使用常量的好处就在于灵活,程序中多次用...
  • const常量

    2014-07-28 11:41:17
    const对象定义常量,一旦创建后其值不得改变,所以const对象必须初始化。 在默认情况下,const对象被设定为仅在文件内有效。当多个文件中出现了同名的const变量,其实等同于在不同文件中分别定义了独立的变量。 1...
  • ES6之- const常量是否真的不能被修改?

    千次阅读 2020-05-21 15:41:54
    const的定义:是一个只读的常量,一旦声明,不可修改 是否真的不能修改?敲几段代码看一下 由上图可看到,const定义string常量后,尝试... 因为const常量保证值不能被改变,其实保证的是指向的内存地址的值不能被修
  • 全局变量 const常量 static

    千次阅读 2017-06-05 21:20:05
    1. 全局变量、const和extern: 如果const对象在编译时可以确定其值,可以将其放在头文件中定义。这样做的原因是 const对象默认情况下是定义该变量的所在文件的局部变量,这样即使次头文件被多个包含,都不会在包含...
  • C语言中const定义常量和宏常量的区别1.const定义常量2.宏常量3.两者区别(1) 编译器处理方式不同(2) 类型和安全检查不同(3) 存储方式不同 1.const定义常量 关键字const 定义的是变量不是常量, 而是去改变一个变量的...
  • Kotlin中的const常量

    千次阅读 2017-09-14 10:08:46
    Kotlin中的const常量
  • 忘了是从哪里听说的了,说是“在C标准中不可以,但是在C++标准中可以这样做”。...对于扩展名是.c的源文件,声明数组长度时用const变量无法过编译。 对于扩展名是.cpp的源文件,可以过编译。
  •  不过,在c++中,effective c++中曾指出过,尽量用const 定义常量,来替换宏定义。  const double PI = 3.1415;  好处: const 替换 宏定义后,编译时能进行类型检查,一旦出错后,比宏定义更方便调试。 2. ...
  • 关于C++中的Const常量

    千次阅读 2014-07-20 10:13:19
    为什么需要常量  (1)如果不使用常量,直接在程序中填写数字或字符串,将会有什么麻烦: 1. 程序的可读性(可理解性)变差。程序员自己会忘记那些数字或字符串是什么意 思,用户则更加不知它们从何处来、表示...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 258,585
精华内容 103,434
关键字:

const常量