C如何用宏区别常量资源和变量资源？

true_casey

1. static
   
2. void testB (char *src)
   
3. {
   
4.         /* 判断传入的src 是属于 @1/2/3 ??? */
   
5.         do_somthing ();
   
6. }
   
7. 
   
8. static
   
9. void testA (char *src)
   
10. {
    
11.         char *a = "hello world";
    
12.         char b[100] = "hello world";
    
13. 
    
14.         testB (a);                                        /* @1 */
    
15.         testB (b);                                        /* @2 */
    
16.         testB ("hello world" );                                /* @3 */
    
17. }

复制代码

@1 有名常量
@2 缓冲资源
@3 未名常量

怎么用宏去区别啊？？？

myworkstation

编译器和语言并没有直观的提供什么功能去实现这个处理，可以换个思路，在C中有四个存储类型static,automatic,register,dynamic。每种类型的存储的地址都是可识别的，通过对存储地址的判断可以识别实事的变量或常量变型。
char *a = "hello world";testB (a); 和　testB ("hello world" );  这两个调用实际上是一样的。编译器在处理的时候会把对hello world的变引指向相同的地方（编译器基本都这么进行优化处理，不属于标准规定）。根据上述说法那下面的公式成立：编译器对常量变量的内存处理策略＋操作系统的内存布局＝可明确定位的内存识别。由于操作系统的内存布局因系统而定，编译器的实现也各有不同，所以就算得出结论要实现相关处理的代码也是很难进行移植的。下面是完成相关功能的代码在linux下测试通过。

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <string.h>
   
4. 
   
5.     int global_dummy = 0;
   
6.     static
   
7.     void testB (char *src)
   
8.     {
   
9.             /* 判断传入的src 是属于 @1/2/3/4*/
   
10.             int local_dummy = 0;
    
11.             if( (unsigned long)src < (unsigned long )&local_dummy ){
    
12.                 //if( src > testB ){
    
13.                     if(  (unsigned long )src <  (unsigned long )&global_dummy ){
    
14.                         printf("string literal\n\n");
    
15.                     }
    
16.                     else if (  (unsigned long ) src > (unsigned long ) &global_dummy){
    
17.                         printf("malloc string\n\n");
    
18.                     }
    
19.                 //}
    
20.             }
    
21.             else
    
22.             {
    
23.                 printf("array: stack\n\n");
    
24.             }
    
25.     }
    
26.     static
    
27.     void testA ()
    
28.     {
    
29.             char *a = "hello world";
    
30.             char b[100] = "hello world";
    
31.             char *c = malloc(100);
    
32.             strcpy(c,a);
    
33.             printf("char *a = \"hello world\";\n");
    
34.             testB (a);                                        /* @1 */
    
35.             printf("char b[100] = \"hello world\";\n");
    
36.             testB (b);                                        /* @2 */
    
37.             printf(" (\"hello world\" )\n");
    
38.             testB ("hello world" );                                /* @3 */
    
39.             printf("char *c = malloc(100);\n");
    
40.             testB (c );                                /* @4 */
    
41.             free(c);
    
42.     }
    
43. 
    
44. int main(int argc,const char** argv)
    
45. {
    
46.     testA();
    
47.     return 0;
    
48. }
    

复制代码

程序的运行结果如下：
char *a = "hello world";
string literal

char b[100] = "hello world";
array: stack

("hello world" )
string literal

char *c = malloc(100);
malloc string


下面贴个linux下程序运行的内存布局图，可以加深对上述代码的理解

bruceteen

char *a = "hello world";
之所以能编译通过，是因为编译器网开一面，以照顾旧有的海量代码。但不等于说 a[] 就是可写的，码农得自己保证不修改a[]值。
换种说法，看到以前代码中 char *a = "hello world"; 就不用改了，能编译通过；但正在写的代码，可不能这样，得写成正确的 const char *a = "hello world";

lxyscls

屌爆了，完全不懂{:3_188:}

myworkstation

回复 3# bruceteen


    你的提醒很有必要，这个行为在不同的c和c++的编译器上有会不同的行为，应该说char *a = "hello world";这种写法不能算错误的写法，所以c编译器不报错也不警告，就此问题稍微展开一下，说说这个做具体会有什么样的行为。早期的K&C认为这是完全合法的，但从K&C第二版标准开始就明确指出“修改string literal的结果是未定义的，字符串并不总是可修改的，可能会放在只读内存区域“。从C89开始，这个问题有了更明确的规定。char *a = "hello world"；定义a是一种字符指针类并使用指定的字符数组（类型为array of char)“hello world"初始化，如果试图修改数组的内容行为将是未定义的。关键的解释就在"未定义“这个解释上，实际上未定义不是错误，它在这里表示代码不可移值。所以在c89和c99规范的”公共扩展“部分有如下规则：String literals是可修改的，此时指向另外一个内容完全相同的对象。在c++中则有区别，c++2003标准规定string literal是由const字符数组构成的（array of n　const char）,所以Ｃ＋＋明确了string literal是不可修改的。C++没有规定所有内容相同的string literal会指向同一个对象（相同的内容指向唯一的对象），这是由编译器实现决定的，同时指出了试图修改string literal的行为是未定义的。为了兼容C，所以不加const 的char*依然是可用的，但通常编译器会给出警告。最后Ｃ＋＋标准明确规定不赞成这样做（deprecated）。　修饰为deprecated表示将来不再支持这个特性。


这个问题要解释清楚就得看标准了。下面是相关标准中的信息摘要：

C99
char *p = "abc";
defines p with type ‘‘pointer to char’’ and initializes it to point to an object with type ‘‘array of char’’
with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to
modify the contents of the array, the behavior is undefined.

J.5.5 Writable string literals
1 String literals are modifiable (in which case, identical string literals should denote distinct
objects) (6.4.5).

C++2003
An ordinary string literal has type “array of n
const char” and static storage duration.

Whether all string literals are distinct (that is, are stored in nonoverlapping objects) is implementationdefined.
The effect of attempting to modify a string literal is undefined.

D.4 Implicit conversion from const strings [depr.string]
1 The implicit conversion from const to non-const qualification for string literals (4.2) is deprecated.