数组和指针的区分

C++/C程序中,指针和数组在诸多地方得相互替换着用,让人产生相同种错觉,以为两者是齐价格的。

   
数组要么在静态存储区被创造(如全局数组),要么在栈上被创造。数组名对承诺着(而不是恃为)一片内存,其地点与容量在生命期内维持无转换,只出反复组的情节可以变动。

指南针可以随时对任意档次的内存块,它的性状是“可转换”,所以我们常用指针来操作动态内存。指针远较数组灵活,但为又危急。

脚坐字符串为条例比较指针与数组的表征。

1 改内容

      
示例1中,字符数组a的容量是6只字符,其情节吧hello\0。a的始末可变动,如a[0]=
‘X’。指针p指向常量字符串“world”(位于静态存储区,内容呢world\0),常量字符串的内容是不可以叫改动的。从语法上看,编译器并无觉得语句p[0]=
‘X’有什么不妥,但是该语句企图修改常量字符串的情节要致运行错误。

char a[] = “hello”;

a[0] = ‘X’;

cout << a << endl;

char *p = “world”;     // 注意p指向常量字符串

p[0] = ‘X’;             // 编译器不能发现该错误

cout << p << endl;

以身作则1 改数组和指针的始末

2 情复制和比

   
不能够针对数组叫进行直接复制和比较。示例2蒙受,若想管数组a的情复制给数组b,不克就此讲话
b = a
,否则用生编译错误。应该为此规范库函数strcpy进行复制。同理,比较b和a的情是否一律,不克为此if(b==a)
来判断,应该为此专业库函数strcmp进行比。

    语句p = a
并无克把a的情节复制指针p,而是把a的地方与给了p。要惦记复制a的情,可以预先用库函数malloc为p申请一片容量为strlen(a)+1单字符的内存,再就此strcpy进行字符串复制。同理,语句if(p==a)
比较的匪是情而是地址,应该为此库函数strcmp来比。

    // 数组…

    char a[] = "hello";

    char b[10];

    strcpy(b, a);           // 不能用   b = a;

    if(strcmp(b, a) == 0)   // 不能用  if (b == a)

    // 指针…

    int len = strlen(a);

    char *p = (char *)malloc(sizeof(char)*(len+1));

    strcpy(p,a);            // 不要用 p = a;

    if(strcmp(p, a) == 0)   // 不要用 if (p == a)

示范2 数组和指针的情节复制和较

3 计内存容量

   
用运算符sizeof可以算出数组的容量(字节数)。示例3(a)中,sizeof(a)的价值是12(注意别忘了’\0’)。指针p指向a,但是sizeof(p)的价也是4。这是为sizeof(p)得到的凡一个指针变量的字节数,相当给sizeof(char*),而不是p所指的内存容量。C++/C语言没有辙知道指针所依的内存容量,除非在提请外存时记住它们。

留意当数组作为函数的参数进行传递时,该数组自动退化为同品种的指针。演示3(b)中,不论数组a的容量是多少,sizeof(a)始终当sizeof(char
*)。

    char a[] = "hello world";

    char *p  = a;

    cout<< sizeof(a) << endl;   // 12字节

    cout<< sizeof(p) << endl;   // 4字节

以身作则3(a) 计算数组和指针的内存容量

 

    void Func(char a[100])

    {

        cout<< sizeof(a) << endl;   // 4字节而不是100字节

}

示范3(b) 数组退化为指针


指南针和数组之字符串的界别

  1. 字符串宏 #define CONST_STR “const str”
    宏于预编译的时节会交替成实际上的值
    2.数组
    数组名对应一片内存,在生命周期内该地址及容量不见面变动,数组里面的内容好换。
    3.指针 指针指于同块内存,如果借助为字符串常量(RO),则不可知改改内容。
    如果申请了同等片内存,复制字符串常量,则可改内容

  2. #include <stdio.h>

  3. #include <string.h>
  4. #include <unistd.h>
  5. #include <stdlib.h>
      1. #define CONST_STR “const
        string”
  6. typedef void (*string_test_routine_t)();
    1. void pointer_strcpy_macro(void)
  7. {
  8.     char *p;
  9.     p = (char*)malloc(100);
  10.     strcpy(p, CONST_STR);
  11.     printf(“char *p;\np = (char
    *)malloc(100);\nstrcpy(p, CONST_STR);\np[0] =
    ‘a’;\n”);
  12.     printf(“\n”);
  13.     p[0] = ‘a’;
  14.     printf(“–> ok\n\n\n”);
  15. }
  16. void pointer_strcpy_string(void)
  17. {
  18.     char *p;
  19.     p = (char*)malloc(100);
  20.     strcpy(p, “const string”);
  21.     printf(“char *p;\np = (char
    *)malloc(100);\nstrcpy(p, \”const string\”);\np[0] = ‘a’;\n”);
  22.     printf(“\n”);
  23.     p[0] = ‘a’;
  24.     printf(“–> ok\n\n\n”);
  25. }
    1. void pointer_macro_string(void)
  26. {
  27.     char *p = CONST_STR;
  28.     printf(“char *p = CONST_STR;\np[0] = ‘a’;
    \n”);
  29.     printf(“\n”);
  30.     p[0] = ‘a’;
  31.     printf(“–> ok\n\n\n”);
  32. }
    1. void pointer_string(void)
  33. {
  34.     char *p = “const string”;
  35.     printf(“char *p = \”const string\”;\np[0] = ‘a’; \n”);
  36.     printf(“\n”);
  37.     p[0] = ‘a’;
  38.     printf(“–> ok\n\n\n”);
  39. }
      1. void array_macro_string(void)
  40. {
  41.     char a[100] = CONST_STR;
  42.     printf(“char a[100] = CONST_STR;\na[0] = ‘a’;
    \n”);
  43.     printf(“\n”);
  44.     a[0] = ‘a’;
  45.     printf(“–> ok\n\n\n”);
  46. }
      1. void array_string(void)
  47. {
  48.     char a[100] = “const string”;
  49.     printf(“char a[100] = \”const string\”;\na[0] = ‘a’; \n”);
  50.     printf(“\n”);
  51.     a[0] = ‘a’;
  52.     printf(“–> ok\n\n\n”);
  53. }
  54. void array_strcpy_string(void)
  55. {
  56.     char a[100];
  57.     strcpy(a, “const string”);
  58.     printf(“char a[100];\nstrcpy(a, \”const string\”);\na[0] = ‘a’;\n”);
  59.     printf(“\n”);
  60.     a[0] = ‘a’;
  61.     printf(“–> ok\n\n\n”);
  62. }
    1. void array_strcpy_macro(void)
  63. {
  64.     char a[100];
  65.     strcpy(a, CONST_STR);
  66.     printf(“char a[100];\nstrcpy(a,
    CONST_STR);\na[0] = ‘a’;\n”);
  67.     printf(“\n”);
  68.     a[0] = ‘a’;
  69.     printf(“–> ok\n\n\n”);
  70. }
    1. static string_test_routine_t func_base[] = {
  71.     array_strcpy_string,
  72.     array_macro_string,
  73.     array_string,
  74.     array_strcpy_macro,
  75.     pointer_macro_string,
  76.     pointer_string,
  77.     pointer_strcpy_macro,
  78.     pointer_strcpy_string
  79. };
    1. #define NUM_FUNC (sizeof
      (func_base) / sizeof(func_base[0]))
    1. void test_string(void)
  80. {
  81.     pid_t pid;
  82.     int i = 0;
  83.     string_test_routine_t * func = func_base;
    1.     for ( i = 0; i < NUM_FUNC; i++ )
  84.     {
  85.         pid = fork();
  86.         if ( pid < 0 )
  87.         {
  88.             printf(“fork() err\n”);
  89.         }
  90.         else if ( pid == 0 )
  91.         {
  92.             (func[i])();
  93.             exit(0);
  94.         }
  95.         else
  96.         {
  97.             sleep( 1 );
  98.         }
  99.     }
  100. }
    1. int main()
  101. {
  102.     test_string();
    1.     return 0;
  103. }