Là khởi tạo một char [] với một chuỗi thực hành xấu theo nghĩa đen?

Tôi đã đọc một chủ đề có tiêu đề "strlen vs sizeof" trên CodeGuru và một trong những câu trả lời nói rằng "đó là cách thực hành tồi [sic] để khởi tạo [sic] một charmảng với một chuỗi ký tự."

Điều này có đúng không, hay đó chỉ là ý kiến ​​của anh ấy (mặc dù là "thành viên ưu tú")?

Đây là câu hỏi ban đầu:

#include <stdio.h>
#include<string.h>
main()
{
    char string[] = "october";
    strcpy(string, "september");

    printf("the size of %s is %d and the length is %d\n\n", string, sizeof(string), strlen(string));
    return 0;
}

đúng. kích thước nên là chiều dài cộng 1 có?

đây là đầu ra

the size of september is 8 and the length is 9

kích thước nên là 10 chắc chắn. Nó giống như tính toán chuỗi sizeof trước khi nó được thay đổi bởi strcpy nhưng độ dài sau.

Có cái gì đó sai với cú pháp của tôi hoặc những gì?

Đây là câu trả lời :

Dù sao, đó là cách thực hành tồi để khởi tạo một mảng char với một chuỗi ký tự. Vì vậy, luôn luôn làm một trong những điều sau đây:

const char string1[] = "october";
char string2[20]; strcpy(string2, "september");

Dù sao, đó là cách thực hành tồi để khởi tạo một mảng char với một chuỗi ký tự.

Tác giả của bình luận đó không bao giờ thực sự biện minh cho nó, và tôi thấy tuyên bố khó hiểu.

Trong C (và bạn đã gắn thẻ này là C), đó là cách duy nhất để khởi tạo một mảng charcó giá trị chuỗi (khởi tạo khác với gán). Bạn có thể viết

char string[] = "october";

hoặc là

char string[8] = "october";

hoặc là

char string[MAX_MONTH_LENGTH] = "october";

Trong trường hợp đầu tiên, kích thước của mảng được lấy từ kích thước của trình khởi tạo. Các chuỗi ký tự được lưu trữ dưới dạng các mảng charcó 0 byte kết thúc, vì vậy kích thước của mảng là 8 ('o', 'c', 't', 'o', 'b', 'e', ​​'r', 0). Trong hai trường hợp thứ hai, kích thước của mảng được chỉ định là một phần của khai báo (8 và MAX_MONTH_LENGTH, bất cứ điều gì xảy ra).

Những gì bạn không thể làm là viết một cái gì đó như

char string[];
string = "october";

hoặc là

char string[8];
string = "october";

vv Trong trường hợp đầu tiên, tuyên bố stringlà không đầy đủ vì không có kích thước mảng đã được xác định và không có khởi tạo để có những kích thước từ. Trong cả hai trường hợp, =sẽ không hoạt động vì a) một biểu thức mảng như stringcó thể không phải là mục tiêu của một bài tập và b) =toán tử không được xác định để sao chép nội dung của một mảng sang một mảng khác.

Tương tự như vậy, bạn không thể viết

char string[] = foo;

nơi foolà một mảng của char. Hình thức khởi tạo này sẽ chỉ hoạt động với chuỗi ký tự.

BIÊN TẬP

Tôi nên sửa đổi điều này để nói rằng bạn cũng có thể khởi tạo các mảng để giữ một chuỗi với trình khởi tạo kiểu mảng, như

char string[] = {'o', 'c', 't', 'o', 'b', 'e', 'r', 0};

hoặc là

char string[] = {111, 99, 116, 111, 98, 101, 114, 0}; // assumes ASCII

nhưng nó dễ dàng hơn trong mắt để sử dụng chuỗi ký tự.

CHỈNH SỬA ²

Để gán nội dung của một mảng bên ngoài khai báo, bạn cần sử dụng strcpy/strncpy(đối với các chuỗi kết thúc 0) hoặc memcpy(đối với bất kỳ loại mảng nào khác):

if (sizeof string > strlen("october"))
  strcpy(string, "october");

hoặc là

strncpy(string, "october", sizeof string); // only copies as many characters as will
                                           // fit in the target buffer; 0 terminator
                                           // may not be copied, but the buffer is
                                           // uselessly completely zeroed if the
                                           // string is shorter!

Vấn đề duy nhất tôi nhớ là gán chuỗi ký tự cho char *:

char var1[] = "september";
var1[0] = 'S'; // Ok - 10 element char array allocated on stack
char const *var2 = "september";
var2[0] = 'S'; // Compile time error - pointer to constant string
char *var3 = "september";
var3[0] = 'S'; // Modifying some memory - which may result in modifying... something or crash

Ví dụ: lấy chương trình này:

#include <stdio.h>

int main() {
  char *var1 = "september";
  char *var2 = "september";
  var1[0] = 'S';
  printf("%s\n", var2);
}

Điều này trên nền tảng của tôi (Linux) gặp sự cố khi nó cố ghi vào trang được đánh dấu là chỉ đọc. Trên các nền tảng khác, nó có thể in 'Tháng Chín', v.v.

Điều đó nói rằng - khởi tạo theo nghĩa đen làm cho số lượng đặt phòng cụ thể để việc này sẽ không hoạt động:

char buf[] = "May";
strncpy(buf, "September", sizeof(buf)); // Result "Sep"

Nhưng điều này sẽ

char buf[32] = "May";
strncpy(buf, "September", sizeof(buf));

Như nhận xét cuối cùng - tôi hoàn toàn không sử dụng strcpy:

char buf[8];
strcpy(buf, "very long string very long string"); // Oops. We overwrite some random memory

Trong khi một số trình biên dịch có thể thay đổi nó thành cuộc gọi an toàn strncpythì an toàn hơn nhiều:

char buf[1024];
strncpy(buf, something_else, sizeof(buf)); // Copies at most sizeof(buf) chars so there is no possibility of buffer overrun. Please note that sizeof(buf) works for arrays but NOT pointers.
buf[sizeof(buf) - 1] = '\0';

Một điều mà không chủ đề nào đưa ra là:

char whopping_great[8192] = "foo";

so với

char whopping_great[8192];
memcpy(whopping_great, "foo", sizeof("foo"));

Các cựu sẽ làm một cái gì đó như:

memcpy(whopping_great, "foo", sizeof("foo"));
memset(&whopping_great[sizeof("foo")], 0, sizeof(whopping_great)-sizeof("foo"));

Cái sau chỉ làm memcpy. Tiêu chuẩn C khẳng định rằng nếu bất kỳ phần nào của mảng được khởi tạo thì tất cả đều như vậy. Vì vậy, trong trường hợp này, tốt hơn là tự làm điều đó. Tôi nghĩ rằng đó có thể là những gì treuss đã nhận được.

Chắc chắn

char whopping_big[8192];
whopping_big[0] = 0;

tốt hơn một trong hai:

char whopping_big[8192] = {0};

hoặc là

char whopping_big[8192] = "";

ps Đối với điểm thưởng, bạn có thể làm:

memcpy(whopping_great, "foo", (1/(sizeof("foo") <= sizeof(whopping_great)))*sizeof("foo"));

để ném một khoảng thời gian biên dịch cho sai số 0 nếu bạn sắp tràn mảng.

Chủ yếu bởi vì bạn sẽ không có kích thước của char[]một biến / cấu trúc mà bạn có thể dễ dàng sử dụng trong chương trình.

Mẫu mã từ liên kết:

 char string[] = "october";
 strcpy(string, "september");

stringđược phân bổ trên ngăn xếp dài 7 hoặc 8 ký tự. Tôi không thể nhớ lại liệu nó có bị chấm dứt theo cách này hay không - chủ đề bạn liên kết để nói rằng nó là.

Sao chép "tháng chín" qua chuỗi đó là một tràn bộ nhớ rõ ràng.

Một thách thức khác xảy ra nếu bạn chuyển stringsang hàm khác để hàm kia có thể ghi vào mảng. Bạn cần nói cho hàm khác biết thời gian của mảng là bao lâu để nó không tạo ra lỗi tràn. Bạn có thể vượt qua stringcùng với kết quả của strlen()nhưng luồng giải thích làm thế nào điều này có thể nổ tung nếu stringkhông bị chấm dứt null.

Tốt hơn hết là bạn nên phân bổ một chuỗi có kích thước cố định (tốt nhất là được xác định là hằng số) và sau đó chuyển mảng và kích thước cố định sang hàm khác. Nhận xét của @John Bode là chính xác và có nhiều cách để giảm thiểu những rủi ro này. Họ cũng đòi hỏi nhiều nỗ lực hơn từ phía bạn để sử dụng chúng.

Theo kinh nghiệm của tôi, giá trị tôi khởi tạo char[]thường là quá nhỏ so với các giá trị khác tôi cần đặt ở đó. Sử dụng một hằng số xác định giúp tránh vấn đề đó.

sizeof stringsẽ cung cấp cho bạn kích thước của bộ đệm (8 byte); sử dụng kết quả của biểu thức đó thay vì strlenkhi bạn quan tâm đến bộ nhớ.
Tương tự, bạn có thể thực hiện kiểm tra trước lệnh gọi strcpyđể xem liệu bộ đệm đích của bạn có đủ lớn cho chuỗi nguồn không : if (sizeof target > strlen(src)) { strcpy (target, src); }.
Có, nếu bạn phải truyền mảng cho hàm, bạn cũng cần chuyển cả kích thước vật lý của nó : foo (array, sizeof array / sizeof *array);. - John Bode

Tôi nghĩ ý tưởng "thực hành xấu" xuất phát từ thực tế là hình thức này:

char string[] = "october is a nice month";

làm cho ngầm một strcpy từ mã máy nguồn đến ngăn xếp.

Sẽ hiệu quả hơn khi chỉ xử lý một liên kết đến chuỗi đó. Thích với:

char *string = "october is a nice month";

hoặc trực tiếp:

strcpy(output, "october is a nice month");

(nhưng tất nhiên trong hầu hết các mã có lẽ không thành vấn đề)

Không bao giờ là thời gian thực sự dài, nhưng bạn nên tránh khởi tạo char [] thành chuỗi, bởi vì, "chuỗi" là const char * và bạn đang gán nó cho char *. Vì vậy, nếu bạn chuyển char [] này cho phương thức thay đổi dữ liệu, bạn có thể có hành vi thú vị.

Như commend đã nói tôi trộn một chút char [] với char *, điều đó không tốt vì chúng khác nhau một chút.

Không có gì sai khi gán dữ liệu cho mảng char, nhưng vì ý định sử dụng mảng này là sử dụng nó dưới dạng 'chuỗi' (char *), rất dễ quên rằng bạn không nên sửa đổi mảng này.