Why use const char *prt1 when we can't change the containing of the pointer

Question

If we use for example:

   char* strs[2];
    strs[1] = "Hello";
    strs[2] = "World!";
    strcat(strs[1],strs[2]);

Then an access violation comes up (Access violation writing location 0x0028CC75).

So why use const char *strs[2]; since the strs1[1], strs1[2] cannot be changed?

Answer 1

// string literals are non-writeable so const is appropriate here
const char* strs[2] = {"Hello", "World!"};
// let's create a target buffer with sufficient space
char buffer[20];
// copy the first string there
strcpy(buffer, strs[0]);
// add the second string there
strcat(buffer, strs[1]);

Answer 2

Two sources of access violation in your case

1. String literals are read only and writing to them is undefined behavior

2. In c arrays are 0 index based, so strs[2] does not exist, only strs[0] and strs[1].

Using const prevents you from accidentally modifying them, but it does not forbid you.

Arrays are modifiable though,

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

int
main(void)
 {
    char strs[2][11] = {"Hello", "World"};
    strcat(strs[0], strs[1]);
    return 0;
 }

the above works as you expected it.

Here it is how you would do it correctly with dynamic allocation

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

char *
autostrcat(const char *const head, const char *const tail)
 {
    char  *result;
    size_t headlen;
    size_t taillen;

    if ((head == NULL) || (tail == NULL))
        return NULL;

    headlen = strlen(head);
    taillen = strlen(tail);
    result  = malloc(1 + headlen + taillen);
    if (result == NULL)
        return NULL;
    memcpy(result, head, headlen);
    memcpy(&result[headlen], tail, taillen);

    result[headlen + taillen] = '\0';
    return result;
 }

int
main(void)
 {
    const char *strs[2] = {"Hello", "World"};
    char *result = autostrcat(strs[0], strs[1]);
    if (result != NULL)
        printf("%s\n", result);
    free(result);
    return 0;
 }

Since you used strlen() you know what the lengths of the strings are, so using strcat() would be unecessarily expensive because it would again figure out the length of the first string as strlen() does.

Answer 3

Wow. So much wrong.

1. Arrays are 0 based, not 1 based in C.
2. The strings are based in program space, most likely, so aren't writeable.

you should create a buffer, and then fill it.

char* concat = (char *) _alloca(strlen(strs[0]) + strlen(strs[1])+1);
strcpy(concat, strs[0]);
strcat(concat, strs[1]);