带有 char[] 的 C 指针，忽略 const 关键字？

Question

I made a little function in C which copies a char array. I didn't want source to be changed, so I put const into the function declaration and body, but it changed.

main.c

#include "copy_char.h"
#include <stdio.h>

int main(void)
{
  char source[] = { 'h', 'e', 'l', 'l', 'o', 0 };
  char dest[] = { 'a', 'b', 'c', 0 };

  printf("%s\n", source); // hello
  printf("%s\n", dest); // abc

  copy_char(source, dest);
  
  printf("%s\n", source); // o (?) - why did this change? 
  printf("%s\n", dest); // hello
}

copy_char.c

#include "copy_char.h"

void copy_char(const char* source, char* dest)
{
  while(*source != 0)
  {
    *dest++ = *source++; 
  }

  *dest = 0;
}

copy_char.h

#ifndef COPYCHAR_H
#define COPYCHAR_H

void copy_char(const char* source, char* dest);

#endif /* COPYCHAR_H */

Can anyone explain to me, why did my source char array change from hello to o ?

Answer 1

Buffer overrun. The string source is longer than the memory allocated for dest , so when you copy source to dest you are tromping over memory you didn't intend to. Weird things then happen (undefined behavior).

You can make dest big enough by declaring its size to be big enough for "hello":

char dest[6] = { 'a', 'b', 'c', 0 };

Answer 2

I didn't want source to be changed, so I put const into function declaration and body. but, it changed

The const qualifier does not magically protect you from writing where you should not. It's merely a contract between you and the compiler that says "trust me, I am not going to modify the memory pointed to by this pointer".

In your function you are writing data past the end of dest , which is undefined behavior. You should either:

1. Pass a maximum length to the function:

    void copy_char(const char* source, char* dest, size_t maxlen) { size_t i; for (i = 0; i < maxlen && source[i]; i++) { dest[i] = source[i]; } dest[i] = 0; }

2. Stop at either *source == 0 or *dest == 0 :

    void copy_char(const char* source, char* dest) { while(*source != 0 && *dest != 0) { *dest++ = *source++; } *dest = 0; }

3. Create a big enough dest array and leave the function unchanged.

The semantics of the function change depending on which option you choose, which one is the right one is up to you.

What most likely is happening in your case is that it just so happens that source is right past the end of dest , so you overwrite the contents of dest with 'h','e','l','l' , then the first character of source with 'o' and then the second one with '\\0' . Luckily enough, your program does not crash, and you end up with a valid string in source that is "o" . Nonetheless, you should never rely on undefined behavior , whether your program seems to magically work or not.