embedded c pointer
程序

嵌入式 C 语言二级指针

二级指针相对于一级指针，显得更难，难在于指针和数组的混合，定义不同类型的二级指针，在使用的时候有着很大的区别。

第一种内存模型char *arr[]

若有如下定义


char *arr[] = {"abc", "def", "ghi"};

这种模型为二级指针的第一种内存模型，在理解的时候应该这样理解：定义了一个指针数组（char * []），数组的每个元素都是一个地址。

在使用的时候，若要使用中间量操作元素，那么此时中间量应该定义为


char *tmp = NULL;

如果要打印这个数组，那么可以使用以下函数


int printAarray(char **pArray, int num)
{
  int i = 0;
  if (pArray == NULL)
  {
    return -1;
  }
  for (i = 0; i < num; i++)
  {
    printf("%s \n", pArray[i]);
  }
  return 0;
}

第二种内存模型char arr[][]

若有如下定义


char arr[3][5] = {"abc", "def", "ghi"};

这种模型为二级指针的第二种内存模型，在理解的时候应该这样理解：定义了一个二维数组，有3个（5个char）空间的存储变量。

在使用的时候，若要使用中间量操作元素，那么此时中间量应该定义为


char tmp[5] = { 0 };

如果要打印这个数组，那么可以使用以下函数


int printAarray(char pArray[][5], int num)
{
  int i = 0;
  if (pArray == NULL)
  {
    return -1;
  }
  for (i = 0; i < num; i++)
  {
    printf("%s \n", pArray[i]);
  }
  return 0;
}

第三种内存模型char **arr

若有如下定义


char **arr = (char *)malloc(100 * sizeof(char *));//char arr[400]
arr[0] = (char *)malloc(100 * sizeof(char));//char buf[100]
arr[1] = (char *)malloc(100 * sizeof(char));
arr[2] = (char *)malloc(100 * sizeof(char));
strcpy(arr[0], "abc");
strcpy(arr[1], "def");
strcpy(arr[2], "ghi");
···
for(int i = 0; i < 3; i++)
 if(arr[i] != NULL)
  free(arr[i]);
free(arr);

这种模型为二级指针的第二种内存模型，在理解的时候应该这样理解：定义了一个二级指针，二级指针就是指向指针的指针，其实就是开辟了100个指针空间，存放了100个地址。这种写法是第一种的简化写法

在使用的时候，若要使用中间量操作元素，那么此时中间量应该定义为


char *tmp = NULL

如果要打印这个数组，那么可以使用以下函数


int printAarray(char **pArray, int num)
{
  int i = 0;
  if (pArray == NULL)
{
    return -1;
  }
  for (i = 0; i < num; i++)
  {
    printf("%s \n", pArray[i]);
  }
  return 0;
}

例子

把第一种内存模型的数据排序,运算结果放到第三种内存模型中


#include "stdio.h"
#include "string.h"
#include "stdlib.h"

char **SortArrayAndGen3Mem(const char **const myArray1, int num, char *str, int *myNum)
{
    char **p = NULL;
    p = (char **)malloc(num * sizeof(char *));
    if (myArray1 == NULL || str == NULL || myNum == NULL) {
        printf("传入参数错误\n");
        p = NULL;
        goto END;
    }
    *myNum = num;
    for (int i = 0; i < num; i++) {
        p[i] = NULL;
        p[i] = (char)malloc(50 * sizeof(char));
        memset(p[i], 0, sizeof(p[i]));
        if (p[i] == NULL) {
            printf("内存分配错误！\n");
            goto END;
        }
        strcpy(p[i], myArray1[i]);
    }
    char *tmp;
    for (int i = 0; i < num; i++) {
        for (int j = i + 1; j < num; j++) {
            if (strcmp(p[i], p[j]) > 0) {
                char *tmp = p[i];
                p[i] = p[j];
                p[j] = tmp;
            }
        }
    }
    for (int i = 0; i < num; i++) {
        printf("%s \n", myArray1[i]);
    }

 END:
    return p;
}

//释放内存函数
void main()
{
    int i = 0;
    char **myArray3 = NULL;
    int num3 = 0;
    //第一种内存模型
    char *myArray[] = { "bbbbb", "aaaaa", "cccccc" };
    char *myp = "111111111111";

    myArray3 = SortArrayAndGen3Mem(myArray, 3, myp, &num3);

    for (i = 0; i < num3; i++) {
        printf("%s \n", myArray3[i]);
    }

    system("pause");
}

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

char **SortArrayAndGet3Mem(const char *const myArray1, int num, char *str, int *myNum);
int getArray(char ***newp, int num);
int freeArray(char ***newpfree, int num);
int sortTArray(char *p, int num);

void main()
{
    char **myArray3 = NULL;
    int num3 = 0;
    char *myArray[] = { "bbbb", "aaa", "cccc" };
    char *myp = "111111111";
    myArray3 = SortArrayAndGet3Mem(myArray, 3, myp, &num3);
    system("pause");
}

char **SortArrayAndGet3Mem(const char **const myArray1, int num, char *str, int *myNum)
{
    int ret = 0;
    char **p = NULL;
    int i = 0;
    char **p1 = NULL;
    p1 = (char **)myArray1;
    ret = getArray(&p, num + 1);
    for (i = 0; i < num; i++) {
        strcpy(p[i], p1[i]);
    }
    strcpy(p[i], str);
    ret = sortTArray(p, num + 1);
    for (i = 0; i < num + 1; i++) {
        printf("%s\n", p[i]);
    }
    ret = freeArray(&p, num + 1);
    *myNum = num + 1;
    return p;
}

int getArray(char ***newp, int num)
{
    int i = 0;
    int ret = 0;
    char **tmp = NULL;
    tmp = (char **)malloc(num * sizeof(char *));
    for (i = 0; i < num; i++) {
        tmp[i] = (char *)malloc(sizeof(char) * 100);
    }
    *newp = tmp;                //
    return 0;
}

//
int freeArray(char ***newpfree, int num)
{
    char **p = NULL;
    int i = 0;
    int ret = 0;
    p = (*newpfree);
    for (i = 0; i < num; i++) {
        free(p[i]);
    }
    free(p);
    *newpfree = NULL;           //
    return ret;
}

//int sortTArray(char ***Arraystr, int num)
int sortTArray(char **Arraystr, int num)
{
    int i, j = 0;
    for (i = 0; i < num; i++) {
        for (j = i + 1; j < num; j++) {
            if (strcmp((Arraystr)[i], (Arraystr)[j]) > 0) {
                char tmp[100];
                strcpy(tmp, (Arraystr)[i]);
                strcpy((Arraystr)[i], (Arraystr)[j]);
                strcpy((Arraystr)[j], tmp);
            }
        }
    }
    for (i = 0; i < num; i++) {
        printf("%s\n", (Arraystr)[i]);
    }
    return 0;
}

C语言程序设计，指针是最难的，希望对朋友有帮助。

相关文章: