精华内容
下载资源
问答
  • 你必须知道的495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    6.3 那么,在C语言中“指针和数组等价”到底是什么意思? 6.4 既然它们这么不同,那为什么作为函数形参的数组和指针声明可以互换呢? 数组不能被赋值 6.5 为什么不能这样向数组赋值?externchar*getpass();...
  • o 2.4 extern 在函数声明中是什么意思? o 2.5 关键字 auto 到底有什么用途? o 2.6 我似乎不能成功定义一个链表。我试过 typedef struct { char *item; NODEPTR next; } *NODEPTR; 但是编译器报了错误信息。难道...
  • 书中内容世界各地的C语言用户多年来在新闻组comp.1ang.c中讨论的成果。作者在网络版CFAQ列表的基础上进行了大幅度的扩充和丰富,结合代码示例,权威而且详细深入地解答了实际学习和工作中最常遇到的495个C语言问题...
  • 《你必须知道的495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    3.20 “semantics of‘’change in ANSI C”的警告是什么意思? 42 3.21 “无符号保护”和“值保护”规则的区别在哪里? 42 第4章 指针 45 基本的指针应用 45 4.1 指针到底有什么好处? 45 4.2 我想声明...
  • 6.3 那么,在C语言中“指针和数组等价”到底是什么意思?  6.4 既然它们这么不同,那为什么作为函数形参的数组和指针声明可以互换呢?  数组不能被赋值  6.5 为什么不能这样向数组赋值?externchar*getpass();...
  • 例如, pf1+pf2是什么意思呢?毫无实际意义。 ②两指针变量进行关系运算 指向同一数组的两指针变量进行关系运算可表示它们所指数组元素之间的关系。例如: pf1==pf2表示pf1和pf2指向同一数组元素 pf1>pf2表示pf1...
  • 6.3 那么,在C语言中“指针和数组等价”到底是什么意思? 64 6.4 既然它们这么不同,那为什么作为函数形参的数组和指针声明可以互换呢? 65 数组不能被赋值 66 6.5 为什么不能这样向数组赋值?extern char *...
  •  6.3 那么,在C语言中“指针和数组等价”到底是什么意思? 6.4 既然它们这么不同,那为什么作为函数形参的数组和指针声明可以互换呢? 数组不能被赋值 6.5 为什么不能这样向数组赋值?externchar*getpass();...
  • 3.20 “semantics of‘>’change in ANSI C”的警告是什么意思? 71 3.21 “无符号保护”和“值保护”规则的区别在哪里? 71 第4章 指针 74 基本的指针应用 74 4.1 指针到底有什么好处? 74 4.2 我想声明一个...
  • 3.20 “semantics of‘>’change in ANSI C”的警告是什么意思? 71 3.21 “无符号保护”和“值保护”规则的区别在哪里? 71 第4章 指针 74 基本的指针应用 74 4.1 指针到底有什么好处? 74 4.2 我想声明一个...
  • 《你必须知道的495个C语言问题》,作者:【美】Steve Summit,翻译:孙云、朱群英。... 6.3 那么,在C语言中“指针和数组等价”到底是什么意思?  6.4 既然它们这么不同,那为什么作为函数形参的数组和...
  • 书中内容世界各地的C语言用户多年来在新闻组comp.1ang.c中讨论的成果。作者在网络版CFAQ列表的基础上进行了大幅度的扩充和丰富,结合代码示例,权威而且详细深入地解答了实际学习和工作中最常遇到的495个C语言问题...
  • 你必须知道的495个C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    1.4 extern 在函数声明中是什么意思? . . . . . . . . . . . . . . . . . 2 1.5 关键字auto 到底有什么用途? . . . . . . . . . . . . . . . . . . . 2 1.6 我似乎不能成功定义一个链表。我试过typedef struct f ...
  • 从Java到C++——常量的使用规则

    千次阅读 2014-05-31 23:05:44
    常量是一种标识符,它的值在运行期间恒定不变。C语言用 #define来定义常量(称为宏常量)。C++ 语言除了 #define外还可以用const来定义...程序员自己会忘记那些数字或字符串是什么意思用户则更加不知它们从何处

    常量是一种标识符,它的值在运行期间恒定不变。C语言用 #define来定义常量(称为宏常量)。C++ 语言除了 #define外还可以用const来定义常量(称为const常量)。

     

    一、为什么需要常量

    如果不使用常量,直接在程序中填写数字或字符串,将会有什么麻烦?

    (1).程序的可读性(可理解性)变差。程序员自己会忘记那些数字或字符串是什么意思,用户则更加不知它们从何处来、表示什么。

    (2).在程序的很多地方输入同样的数字或字符串,难保不发生书写错误。

    (3).如果要修改数字或字符串,则会在很多地方改动,既麻烦又容易出错。

     

    【规则1】 尽量使用含义直观的常量来表示那些将在程序中多次出现的数字或字符串。

    例如:

    #define MAX    100 //  C语言的宏常量

    const int MAX = 100;//  C++ 语言的const常量

    const float PI = 3.14159;//  C++ 语言的const常量

     

    二、const#define的比较

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

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

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

     

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

     

    三、常量定义规则

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

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

    例如:

    const float RADIUS = 100;

    const float DIAMETER = RADIUS * 2;


    四、类中的常量

    有时我们希望某些常量只在类中有效。由于#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定义为static类型。例如

    方法一:

    class A
    {…
    enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量
    int array1[SIZE1];
    int array2[SIZE2];
    };

    方法二:

    class A
    {
    	//…
    	static const int SIZE1 = 100; // 枚举常量
    	static const int SIZE2 = 200; // 枚举常量
    	int array1[SIZE1];	
    	int array2[SIZE2];
    };

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

     

    展开全文
  • C++类中的常量

    2019-01-03 10:12:00
    C++类中的常量  常量是一种标识符,它的值在运行期间恒定不变。C语言用 #define来定义常量(称为宏常量)。C++ 语言除了 #define外还...程序员自己会忘记那些数字或字符串是什么意思用户则更加不知它们从何处来...

    C++类中的常量

        常量是一种标识符,它的值在运行期间恒定不变。C语言用 #define来定义常量(称为宏常量)。C++ 语言除了 #define外还可以用const来定义常量(称为const常量)。

    1 为什么需要常量

    如果不使用常量,直接在程序中填写数字或字符串,将会有什么麻烦?

    1. 程序的可读性(可理解性)变差。程序员自己会忘记那些数字或字符串是什么意思,用户则更加不知它们从何处来、表示什么。
    2. 在程序的很多地方输入同样的数字或字符串,难保不发生书写错误。
    3. 如果要修改数字或字符串,则会在很多地方改动,既麻烦又容易出错。

     

    1. 【规则5-1-1尽量使用含义直观的常量来表示那些将在程序中多次出现的数字或字符串。

    例如:

        #define         MAX   100       /*  C语言的宏常量  */

    const int       MAX = 100;      //  C++ 语言的const常量

    const float     PI = 3.14159;   //  C++ 语言的const常量

    2 const 与 #define的比较

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

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

     

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

    3 常量定义规则

    1. 【规则5-3-1需要对外公开的常量放在头文件中,不需要对外公开的常量放在定义文件的头部。为便于管理,可以把不同模块的常量集中存放在一个公共的头文件中。
    2. 【规则5-3-2如果某一常量与其它常量密切相关,应在定义中包含这种关系,而不应给出一些孤立的值。

    例如:

    const  float   RADIUS = 100;

    const  float   DIAMETER = RADIUS * 2;

    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)。

    展开全文
  • 常量

    2013-01-27 10:31:37
    常量是一种标识符,它的值在运行期间恒定不变。C语言用 #define来定义常量(称为宏常量)。C++ 语言除了 #define外还可以...程序员自己会忘记那些数字或字符串是什么意思用户则更加不知它们从何处来、表示什么。 (2)

    常量是一种标识符,它的值在运行期间恒定不变。C语言用 #define来定义常量(称为宏常量)。C++ 语言除了 #define外还可以用const来定义常量(称为const常量)。

    1 为什么需要常量

    如果不使用常量,直接在程序中填写数字或字符串,将会有什么麻烦?

    (1)程序的可读性(可理解性)变差。程序员自己会忘记那些数字或字符串是什么意思,用户则更加不知它们从何处来、表示什么。

    (2)在程序的很多地方输入同样的数字或字符串,难保不发生书写错误。

    (3)如果要修改数字或字符串,则会在很多地方改动,既麻烦又容易出错。

    【规则5-1-1】 尽量使用含义直观的常量来表示那些将在程序中多次出现的数字或字符串。

    例如:

    #define MAX 100 /* C语言的宏常量 */

    const int MAX = 100; // C++ 语言的const常量

    const float PI = 3.14159; // C++ 语言的const常量

    2 const 与 #define的比较

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

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

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

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

    3 常量定义规则

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

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

    例如:

    const float RADIUS = 100;

    const float DIAMETER = RADIUS * 2;

    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)。

    展开全文
  • C++ 常量

    2015-08-20 10:36:41
    常量是一种标识符,它的值在运行期间恒定不变。C语言用 #define来定义常量(称为宏常量)。  C++ 语言除了 #define外还可以用const...程序员自己会忘记那些数字或字符串是什么意思,  用户则更加不知它们从何处来、
    常量是一种标识符,它的值在运行期间恒定不变。C语言用 #define来定义常量(称为宏常量)。 
    C++ 语言除了 #define外还可以用const来定义常量(称为const常量)。 
    1 为什么需要常量  
    如果不使用常量,直接在程序中填写数字或字符串,将会有什么麻烦? 
    (1)程序的可读性(可理解性)变差。程序员自己会忘记那些数字或字符串是什么意思, 
    用户则更加不知它们从何处来、表示什么。 
    (2)在程序的很多地方输入同样的数字或字符串,难保不发生书写错误。 
    (3)如果要修改数字或字符串,则会在很多地方改动,既麻烦又容易出错。 
    【规则1】 尽量使用含义直观的常量来表示那些将在程序中多次出现的数字或字符串。 
    例如: 
    #define            MAX   100     /*  C语言的宏常量  */  
    const int          MAX = 100;        //  C++ 语言的const常量 
    const float     PI = 3.14159;    //  C++ 语言的const常量 
    2 const 与 #define的比较 
    C++ 语言可以用const来定义常量,也可以用 #define来定义常量。但是前者比后者有更多的优点: 
    (1) const常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换 
    可能会产生意料不到的错误(边际效应)。 
    (2) 有些集成化的调试工具可以对const常量进行调试,但是不能对宏常量进行调试。 
    【规则2】在C++ 程序中只使用const常量而不使用宏常量,即const常量完全取代宏常量。 
    3 常量定义规则 
    【3-1】需要对外公开的常量放在头文件中,不需要对外公开的常量放在定义文件的头部。为便于管理 ,可以把不同模块的常量集中存放在一个公共的头文件中。 
    【规则3-2】如果某一常量与其它常量密切相关,应在定义中包含这种关系,而不应给出一些孤立的值。 

    例如: 
    const  float   RADIUS = 100; 
    const  float   DIAMETER = RADIUS * 2; 
    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)。 


    ========================================

    PS: 使用整个类中都恒定的常量的方法:把常量定义成全局的。例如:
    const int DEFAULT_CONN_NUM =3;
    DBLoader::DBLoader(){}
    不过目前看只能本文件有效,因为别的要引用必须还赋值才行,如下:
           extern const int DEFAULT_CONN_NUM =3;
    修改变量值不方便。
    展开全文
  • C++中的常量

    2015-01-12 21:03:42
    常量是一种标识符,它的值在运行期间恒定不变。C语言用 #define来定义常量(称为宏常量)。  C++ 语言除了 #define外还可以用const...程序员自己会忘记那些数字或字符串是什么意思,  用户则更加不知它们从何处来、
  • 第5章 常量常量是一种标识符,它的值在运行期间恒定不变。C语言用 #define来定义常量(称为宏常量)。C++ 语言除了 #...程序员自己会忘记那些数字或字符串是什么意思用户则更加不知它们从何处来、表示什么。
  • C++/C常量

    2009-06-24 17:13:18
    常量是一种标识符,它的值在运行期间恒定不变。C语言用 #define来定义常量(称为宏常量)。C++ 语言除了 #define外还可以用const来定义常量...程序员自己会忘记那些数字或字符串是什么意思用户则更加不知它们从...
  • 第5章常量  常量是一种标识符,它的值在运行期间恒定不变。C语言用 #define来定义常量(称为宏常量)。C++ 语言除了 #define外还可以用const来定义常量...程序员自己会忘记那些数字或字符串是什么意思用户则更加

空空如也

空空如也

1 2
收藏数 38
精华内容 15
关键字:

c语言用户标识符是什么意思

c语言 订阅