Apakah menginisialisasi char [] dengan string benar-benar praktik buruk?

Saya sedang membaca utas berjudul "strlen vs sizeof" di CodeGuru , dan salah satu balasan menyatakan bahwa "lagian [praktik] buruk untuk menginisialisasi [sic] chararray dengan string literal."

Apakah ini benar, atau apakah itu hanya pendapatnya (walaupun "anggota elit")?

Ini pertanyaan aslinya:

#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;
}

Baik. ukurannya harus panjang plus 1 ya?

ini adalah output

the size of september is 8 and the length is 9

Ukuran harus 10 pasti. itu seperti menghitung sizeof string sebelum diubah oleh strcpy tetapi panjang setelahnya.

Apakah ada yang salah dengan sintaks saya atau apa?

Inilah jawabannya :

Lagi pula itu praktik yang buruk untuk menginisialisasi array char dengan string literal. Jadi selalu lakukan salah satu dari yang berikut:

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

Lagi pula itu praktik yang buruk untuk menginisialisasi array char dengan string literal.

Penulis komentar itu tidak pernah benar-benar membenarkannya, dan saya merasa pernyataan itu membingungkan.

Di C (dan Anda telah menandai ini sebagai C), itu satu-satunya cara untuk menginisialisasi array chardengan nilai string (inisialisasi berbeda dari penugasan). Anda bisa menulis

char string[] = "october";

atau

char string[8] = "october";

atau

char string[MAX_MONTH_LENGTH] = "october";

Dalam kasus pertama, ukuran array diambil dari ukuran initializer. Literal string disimpan sebagai array chardengan terminasi 0 byte, sehingga ukuran array adalah 8 ('o', 'c', 't', 'o', 'b', 'e', ​​'r', 0). Dalam dua kasus kedua, ukuran array ditentukan sebagai bagian dari deklarasi (8 dan MAX_MONTH_LENGTH, apa pun yang terjadi).

Yang tidak bisa Anda lakukan adalah menulis sesuatu

char string[];
string = "october";

atau

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

dll Dalam kasus pertama, deklarasi stringini tidak lengkap karena tidak ada ukuran array telah ditetapkan dan tidak ada initializer untuk mengambil ukuran dari. Dalam kedua kasus, =tidak akan bekerja karena a) ekspresi array seperti stringmungkin bukan target penugasan dan b) =operator tidak didefinisikan untuk menyalin konten dari satu array ke array yang lain.

Dengan token yang sama, Anda tidak dapat menulis

char string[] = foo;

di mana fooarray lain dari char. Bentuk inisialisasi ini hanya akan bekerja dengan string literal.

SUNTING

Saya harus mengubah ini untuk mengatakan bahwa Anda juga dapat menginisialisasi array untuk menahan string dengan penginisialisasi gaya array, seperti

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

atau

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

tetapi lebih mudah di mata untuk menggunakan string literal.

EDIT ²

Untuk menetapkan konten array di luar deklarasi, Anda harus menggunakan strcpy/strncpy(untuk string yang diakhiri 0) atau memcpy(untuk semua jenis array lainnya):

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

atau

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!

Satu-satunya masalah yang saya ingat adalah menetapkan string literal ke 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

Sebagai contoh, ambil program ini:

#include <stdio.h>

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

Ini pada platform saya (Linux) macet karena mencoba untuk menulis ke halaman yang ditandai sebagai hanya-baca. Pada platform lain mungkin mencetak 'September' dll.

Yang mengatakan - inisialisasi secara literal membuat jumlah pemesanan tertentu sehingga ini tidak akan berfungsi:

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

Tapi ini akan

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

Sebagai komentar terakhir - saya tidak akan menggunakan strcpysama sekali:

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

Sementara beberapa kompiler dapat mengubahnya menjadi panggilan strncpyaman jauh lebih aman:

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';

Satu hal yang tidak ditampilkan oleh kedua utas ini adalah:

char whopping_great[8192] = "foo";

vs.

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

Yang pertama akan melakukan sesuatu seperti:

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

Yang terakhir hanya melakukan memcpy. Standar C menegaskan bahwa jika ada bagian dari array yang diinisialisasi, semuanya adalah. Jadi dalam hal ini, lebih baik melakukannya sendiri. Saya pikir itulah yang mungkin terjadi pada treuss.

Tentunya

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

lebih baik daripada:

char whopping_big[8192] = {0};

atau

char whopping_big[8192] = "";

ps Untuk poin bonus, Anda dapat melakukan:

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

untuk membuang waktu kompilasi bagi dengan kesalahan nol jika Anda hendak melimpahi array.

Terutama karena Anda tidak akan memiliki ukuran char[]dalam variabel / konstruksi yang dapat Anda gunakan dengan mudah dalam program.

Contoh kode dari tautan:

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

stringdialokasikan pada tumpukan sepanjang 7 atau 8 karakter. Saya tidak ingat apakah itu diakhiri dengan nol dengan cara ini atau tidak - utas yang Anda tautkan menyatakan bahwa itu adalah nol.

Menyalin "september" pada string itu adalah memori yang jelas dibanjiri.

Tantangan lain muncul jika Anda beralih stringke fungsi lain sehingga fungsi lainnya dapat menulis ke dalam array. Anda perlu memberitahu fungsi lain berapa lama array begitu itu tidak membuat overrun. Anda bisa meneruskan stringdengan hasil strlen()tetapi utas menjelaskan bagaimana ini bisa meledak jika stringtidak diakhiri null.

Anda lebih baik mengalokasikan string dengan ukuran tetap (lebih disukai didefinisikan sebagai konstanta) dan kemudian meneruskan array dan ukuran tetap ke fungsi lainnya. Komentar @John Bode benar, dan ada cara untuk mengurangi risiko ini. Mereka juga membutuhkan lebih banyak upaya dari Anda untuk menggunakannya.

Dalam pengalaman saya, nilai yang saya inisialisasi char[]ke biasanya terlalu kecil untuk nilai-nilai lain yang perlu saya tempatkan di sana. Menggunakan konstanta yang didefinisikan membantu menghindari masalah itu.

sizeof stringakan memberi Anda ukuran buffer (8 byte); gunakan hasil ekspresi itu alih-alih strlensaat Anda khawatir tentang memori.
Demikian pula, Anda dapat membuat cek sebelum panggilan untuk strcpyuntuk melihat jika target buffer Anda cukup besar untuk string sumber: if (sizeof target > strlen(src)) { strcpy (target, src); }.
Ya, jika Anda harus melewati array ke fungsi, Anda harus lulus ukuran fisik juga: foo (array, sizeof array / sizeof *array);. - John Bode

Saya pikir ide "praktik buruk" berasal dari kenyataan bahwa bentuk ini:

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

secara implisit membuat strcpy dari kode mesin sumber ke stack.

Lebih efisien untuk hanya menangani tautan ke string itu. Suka dengan:

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

atau langsung:

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

(tapi tentu saja di sebagian besar kode mungkin tidak masalah)

Tidak pernah terlalu lama, tetapi Anda harus menghindari inisialisasi char [] ke string, karena, "string" adalah const char *, dan Anda menugaskannya ke char *. Jadi, jika Anda meneruskan karakter ini [] ke metode yang mengubah data, Anda dapat memiliki perilaku yang menarik.

Seperti yang saya katakan, saya mencampur sedikit char [] dengan char *, itu tidak bagus karena mereka sedikit berbeda.

Tidak ada yang salah tentang menugaskan data ke array char, tetapi karena niat menggunakan array ini adalah menggunakannya sebagai 'string' (char *), mudah untuk melupakan bahwa Anda tidak boleh memodifikasi array ini.