#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#define STRING_LENGTH 36

int scanf_s(const char *format ,...);

unsigned int search(const char* const stringArray[], unsigned int stringCount, const char* stringToSearch)
{
   for(unsigned int i = 0; i < stringCount; i++)
   {
      if(strcmp(stringArray[i], stringToSearch) == 0)
      {
         return i;
      }
   }

   return UINT_MAX;
}

int main(void)
{
   printf("Enter the count of strings: ");

   unsigned int strCount;
   scanf_s("%u", &strCount);

   char* *strArray = malloc(sizeof(char*) * strCount);
   if(strArray == NULL)
   {
       printf("Could not get memory for the string array!
");
       return EXIT_FAILURE;
   }

   for(unsigned int i = 0; i < strCount; i++)
   {
       strArray[i] = calloc(sizeof(char), STRING_LENGTH);
       if(strArray[i] == NULL)
       {
          printf("Could not get memory for the next string!
");
          return EXIT_FAILURE;
       }

       printf("Enter %uth string (%i characters at most): ", (i + 1), (STRING_LENGTH - 1));
       scanf_s("%s", strArray[i], STRING_LENGTH);
   }

   char* strToSearch = calloc(sizeof(char), STRING_LENGTH);
   if(strToSearch == NULL)
   {
      printf("Could not get memory for the string to be searched!
");
      return EXIT_FAILURE;
   }

   printf("Enter string to be searched (%i characters at most) : ", (STRING_LENGTH - 1));
   scanf_s("%s", strToSearch, STRING_LENGTH);

   unsigned int result = search((const char* const*)strArray, strCount, strToSearch);
   if(result != UINT_MAX) {
      printf("String found at index: %u
", result);
   } else {
      printf("String was not found!
");
   }

   free(strToSearch);
   for(unsigned int i = 0; i < strCount; i++)
   {
       free(strArray[i]);
   }
   free(strArray);

   return EXIT_SUCCESS;
}

Enter the count of strings: 3
Enter 1th string (35 characters at most): Goodbye
Enter 2th string (35 characters at most): Cruel
Enter 3th string (35 characters at most): World
Enter string to be searched (35 characters at most) : Cruel
String found at index: 1

查询here

***************** 移除********************

EDIT:我想增加一些信息。

www.un.org/Depts/DGACM/index_french.htm

<>const char* const arr[ ]与const char* const arr相同。

使用<代码>const char* const* const arr的目的是保护rr的地址、rr的内容和rr的内容。

******** *** ****** *********************************************************************************

EDIT:在发表对问题的答复后,我决定添加一个简短的讲解点。 它侧重于特性点。

We all know that pointers store just memory addresses and not data. If you declare a char* cptr;, it does not yet point to a valid memory address. So, *cptr = a ; is invalid and the compiler produces a warning for that.

int main(void)
{
    char* cptr;
    *cptr =  a ; // gcc -> warning: ‘cptr’ is used uninitialized
    printf("*cptr: %c
", *cptr);
    return 0;
}

如果你试图实施上述方案,就会导致分割法。

为了能够使用名声器,你必须首先将其指向一个有效的记忆地点,如:char* cptr = malloc(sizeof(char) * 6);。 或您可从另一个<代码>char*上指定一个有效记忆点的地址。 含有果园或str。

int main(void)
{
    char* cptr = malloc(sizeof(char));
    *cptr =  a ;
    printf("*cptr: %c
", *cptr);
    free(cptr);

    cptr = malloc(sizeof(char) * 6);
    strcpy(cptr, "Hello");
    printf("*cptr: %s
", cptr);
    free(cptr);
    
    return 0;
}

产出如下:

*cptr: a
*cptr: Hello

<代码>character阵列的长度对于char*> 因为它总是只提到第一种特性的论述,并假定在毗连空间结束时,这种扼杀是完全无效的。

在解释<代码>char*的申报和使用后,现在应当解释使用<代码>const的关键词和特征标识。

Recall that pointers can provide us 3 different values: the addresses of themselves, the addresses they point to and the data at the addresses they point to.

我们可以改变点人的位置,但我们能够改变点人的其他特性。

在最后一项方案中,你认为<代码>*cptr首先指只包含一种特性的记忆点。 之后,它被定为可以储存多达6个特性(包括生态特性)的另一地点。 这一用法是一个例子,说明如何改变协调人所指出的地址。

如果您不想点到另一个地点,则需要使用<条码>。 点名前的关键词如下:char* const cptr

int main(void)
{
    char* const cptr = malloc(sizeof(char));
    *cptr =  a ;
    printf("*cptr: %c
", *cptr);
    free(cptr);

    cptr = malloc(sizeof(char) * 6); // gcc -> error: assignment of read-only variable ‘cptr’
    strcpy(cptr, "Hello");
    printf("*cptr: %s
", cptr);
    free(cptr);
    
    return 0;
}

在上述方案中,汇编者不允许在<代码>*cptr 上指定一个新地址:cptr = malloc(sizeof(char) * 6);<*cptr在方案执行期间注明同一地点。

除了改变点人指出的地址外,你还可以改变在指定地址上的数据。 可以通过如下方式做到这一点:strcpy (cptr, “Hello”);

int main(void)
{
    char* const cptr = malloc(sizeof(char));
    *cptr =  a ;
    printf("*cptr: %c
", *cptr);
    *cptr =  b ;
    printf("*cptr: %c
", *cptr);
//  cptr = malloc(sizeof(char)); // gcc -> error: assignment of read-only variable ‘cptr’
    free(cptr);


    char* const sptr = malloc(sizeof(char) * 6);
    strcpy(sptr, "Hello");
    printf("*sptr: %s
", sptr);
    strcpy(sptr, "World");
    printf("*sptr: %s
", sptr);
//  sptr = malloc(sizeof(char) * 6); // gcc -> error: assignment of read-only variable ‘sptr’
    free(sptr);
    
    return 0;
}

如果你不赞同所评论的内容,你将获得的产出是:

*cptr: a
*cptr: b
*sptr: Hello
*sptr: World

在上述方案中,尽管您可以更改点码<>*cptr和*sptr<>/code>上标明的地址,但您可更改点码上的数据。

如果你想要保护<代码>*cptr所指明的地址上的数据,而不是该地址所指明的数据? 在以下方案中:const char* cptr 可在<代码>*newCharPtr1和上加一>。 但是,<代码>*cptr不能改动其指出的地址上的数据。

int main(void)
{
    const char* cptr;
    char *newCharPtr1 = malloc(sizeof(char));
    *newCharPtr1 =  a ;
    printf("*newCharPtr1: %c
", *newCharPtr1);
    cptr = newCharPtr1;
    printf("*cptr: %c
", *cptr);

    char *newCharPtr2 = malloc(sizeof(char));
    *newCharPtr2 =  b ;
    printf("*newCharPtr2: %c
", *newCharPtr2);
    cptr = newCharPtr2;
    printf("*cptr: %c
", *cptr);

    *cptr =  c ; // gcc -> error: assignment of read-only location ‘*cptr’

    free(newCharPtr1);
    free(newCharPtr2);
    
    return 0;
}

奇怪的是,有时Compilers可以像以下方案那样ool。

int main(void)
{
    const char* sptr;
    char* newStringPtr1 = malloc(sizeof(char) * 6);
    strcpy(newStringPtr1, "Hello");
    printf("*newStringPtr1: %s
", newStringPtr1);
    sptr = newStringPtr1;
    printf("*sptr: %s
", sptr);

    char* newStringPtr2 = malloc(sizeof(char) * 6);
    strcpy(newStringPtr2, "World");
    printf("*newStringPtr2: %s
", newStringPtr2);
    sptr = newStringPtr2;
    printf("*sptr: %s
", sptr);

    // gcc -> warning: passing argument 1 of ‘strcpy’ discards ‘const’ qualifier from pointer target type
    strcpy(sptr, "Cruel");
    // gcc -> /usr/include/string.h:141:39: note: expected ‘char * restrict’ but argument is of type ‘const char *’
    printf("*newStringPtr2: %s
", newStringPtr2);

    putchar( 
 );
    const char* const sptr2 = newStringPtr2;
    printf("*newStringPtr2: %s
", newStringPtr2);
    printf("*sptr2: %s
", sptr2);
    // gcc -> warning: passing argument 1 of ‘strcpy’ discards ‘const’ qualifier from pointer target type
    strcpy(sptr2, "What?");
    // gcc -> /usr/include/string.h:141:39: note: expected ‘char * restrict’ but argument is of type ‘const char *’
    printf("*newStringPtr2: %s
", newStringPtr2);
    printf("*sptr2: %s
", sptr2);

    free(newStringPtr1);
    free(newStringPtr2);
    
    return 0;
}

上述方案的产出是:

*newStringPtr1: Hello
*sptr: Hello
*newStringPtr2: World
*sptr: World
*newStringPtr2: Cruel

*newStringPtr2: Cruel
*sptr2: Cruel
*newStringPtr2: What?
*sptr2: What?

虽然我宣布<代码>*sptr为const char*spitr和*sptr2为const char* constsptr2,但strcpy()>设法在标语上修改数据。 这是你为什么要把TRIEAT WARNINGS作为ERRORS的一个明显例子。

参看你如何设计C Compiler的另一个例子,请查@dbush s 。 页: 1