小编ZPS*_*ZPS的帖子

检查字符数组是否为空的哪种方法最可靠？

char text[50];

if(strlen(text) == 0) {}

要么

if(text[0] == '\0') {}

或者我需要做什么

 memset(text, 0, sizeof(text));
 if(strlen(text) == 0) {}

什么是最有效的方式来解决这个问题？

我特别关注何时在char指针上使用malloc

char *ptr;
ptr = "something";
...code...
...code...
ptr = "something else";

malloc是否会为了这个微不足道的东西？如果是,为什么？如果没有,那么什么时候需要char指针？

我试图获取执行脚本的shell的名称.

为什么

echo $(ps | grep $PPID) | cut -d" " -f4

工作的同时

echo ps | grep $PPID | cut -d" " -f4

才不是？

    typedef struct unit_class_struct {
        char *name;
    } person;



person * setName() {
       person * array;
       array = malloc (2 * sizeof(person));

       array->name = strdup("Robert");
       array++;
       array->name = strdup("Jose");
       return array;
}


    int main()
    {
        person *array;

        array = setName();

        printf("First name is %s\n", array[0].name);
        printf("Second name is %s\n", array[1].name);

        return 0;
    }

在这个例子中,array [0] .name返回Jose,而不是我预期的Robert,而array [1] .name是空的.

但是,如果我使用

person * setName() {
       person * array;
       person * array_switch;
       array = malloc (2 * sizeof(person));
       array_switch = array;
       array_switch->name = strdup("Robert"); …

下面的代码编译,但立即崩溃的原因显而易见,但不是我.我似乎无法做到正确,任何人都可以告诉我如何解决这个问题.

*array_ref[2] = array[0];
*array_ref[3] = array[1];

它每次都在那个部分崩溃.

typedef struct test {
    char *name;
    char *last_name;
} person;



int setName(person ** array, person ***array_ref) {

    *array = malloc (5 * sizeof(person));
    *array_ref= malloc(5 * sizeof(person*));

   array[0]->name = strdup("Bob");
   array[1]->name = strdup("Joseph");
   array[0]->last_name = strdup("Robert");
   array[1]->last_name = strdup("Clark");


*array_ref[2] = array[0];
*array_ref[3] = array[1];


    return 1;
}



int main()
{
    person *array;
    person **array_r;

   setName(&array,&array_r);

    printf("First name is %s %s\n", array[0].name, array[0].last_name);
    printf("Second name is %s %s\n", array_r[3]->name, array_r[3]->last_name);

     while(1) {} …

我想知道为什么结构指针的行为与char指针的行为不同.

typedef struct person_struct {
    char *name;
} person;

changeStructName(person * name1) 
{
name1->name = "Robert";                       
}

changeCharName(char * name2) 
{
name2 = "Jose";                       
}

int main()
{
person * name1;
char * name2;

name1 = malloc(1 * sizeof(person));
changeStructName(name1);
changeCharName(name2);

printf("First name is %s\n",name1->name);
printf("Second name is %s\n",name2);
  }   

我知道使用此代码将起作用:

changeCharName(char ** name2) 
{
*name2 = "Jose";                       
}

changeCharName(&name2);

我只是好奇为什么我不需要对结构的指针设置做同样的指针,以便通过引用进行修改？

例如,我有这个结构和代码:

typedef struct
{
long long *number;
} test;

test * test_structure;
test_structure = malloc(sizeof(test));
test_structure->number = malloc(sizeof(long long) * 100);
free(test_structure->number);
free(test_structure);

与此结构和代码:

typedef struct
{
long long number[100];
} test;

test * test_structure;
test_structure = malloc(sizeof(test));
free(test_structure);

因为我知道这个数字阵列将永远是100,或者是这些方法完全可以接受的,或者是一种方法比其他更好的,为什么？