Làm cách nào để tạo một chuỗi các chuỗi trong C?

Tôi đang cố gắng tạo một chuỗi các chuỗi trong C. Nếu tôi sử dụng mã này:

char (*a[2])[14];
a[0]="blah";
a[1]="hmm";

gcc cho tôi "cảnh báo: gán từ loại con trỏ không tương thích". cách chính xác để làm điều này là gì?

chỉnh sửa: Tôi tò mò tại sao điều này sẽ đưa ra một cảnh báo trình biên dịch vì nếu tôi làm printf(a[1]);, nó sẽ in chính xác "hmm".

Nếu bạn không muốn thay đổi chuỗi, thì bạn có thể làm

const char *a[2];
a[0] = "blah";
a[1] = "hmm";

Khi bạn làm như thế này, bạn sẽ phân bổ một mảng gồm hai con trỏ tới const char. Những con trỏ này sau đó sẽ được đặt thành địa chỉ của chuỗi tĩnh "blah"và "hmm".

Nếu bạn muốn có thể thay đổi nội dung chuỗi thực tế, bạn phải làm một cái gì đó như

char a[2][14];
strcpy(a[0], "blah");
strcpy(a[1], "hmm");

Điều này sẽ phân bổ hai mảng liên tiếp charmỗi 14 giây, sau đó nội dung của các chuỗi tĩnh sẽ được sao chép vào chúng.

Có một số cách để tạo một chuỗi các chuỗi trong C. Nếu tất cả các chuỗi sẽ có cùng độ dài (hoặc ít nhất có cùng độ dài tối đa), bạn chỉ cần khai báo một mảng char 2 chiều và gán nếu cần:

char strs[NUMBER_OF_STRINGS][STRING_LENGTH+1];
...
strcpy(strs[0], aString); // where aString is either an array or pointer to char
strcpy(strs[1], "foo");

Bạn cũng có thể thêm một danh sách các công cụ khởi tạo:

char strs[NUMBER_OF_STRINGS][STRING_LENGTH+1] = {"foo", "bar", "bletch", ...};

Điều này giả định kích thước và số chuỗi trong trình khởi tạo khớp với kích thước mảng của bạn. Trong trường hợp này, nội dung của từng chuỗi ký tự (chính nó là một mảng char kết thúc bằng 0) được sao chép vào bộ nhớ được phân bổ cho strs. Vấn đề với phương pháp này là khả năng phân mảnh nội bộ; nếu bạn có 99 chuỗi có 5 ký tự trở xuống, nhưng 1 chuỗi dài 20 ký tự, 99 chuỗi sẽ có ít nhất 15 ký tự không sử dụng; đó là một sự lãng phí không gian

Thay vì sử dụng mảng char 2-d, bạn có thể lưu trữ một mảng con trỏ 1-d vào char:

char *strs[NUMBER_OF_STRINGS];

Lưu ý rằng trong trường hợp này, bạn chỉ phân bổ bộ nhớ để giữ các con trỏ tới các chuỗi; bộ nhớ cho các chuỗi phải được phân bổ ở nơi khác (dưới dạng mảng tĩnh hoặc bằng cách sử dụng malloc()hoặc calloc()). Bạn có thể sử dụng danh sách trình khởi tạo như ví dụ trước:

char *strs[NUMBER_OF_STRINGS] = {"foo", "bar", "bletch", ...};

Thay vì sao chép nội dung của các hằng chuỗi, bạn chỉ cần lưu trữ các con trỏ tới chúng. Lưu ý rằng hằng chuỗi có thể không ghi được; bạn có thể gán lại con trỏ, như vậy:

strs[i] = "bar";
strs[i] = "foo"; 

Nhưng bạn không thể thay đổi nội dung của chuỗi; I E,

strs[i] = "bar";
strcpy(strs[i], "foo");

có thể không được phép

Bạn có thể sử dụng malloc()để phân bổ động bộ đệm cho từng chuỗi và sao chép vào bộ đệm đó:

strs[i] = malloc(strlen("foo") + 1);
strcpy(strs[i], "foo");

BTW,

char (*a[2])[14];

Khai báo một mảng 2 phần tử con trỏ thành mảng 14 phần tử của char.

Hành động! Chuỗi không đổi:

const char *strings[] = {"one","two","three"};

Nếu tôi nhớ chính xác.

Ồ, và bạn muốn sử dụng strcpy để gán, không phải toán tử =. strcpy_s an toàn hơn, nhưng nó không theo tiêu chuẩn C89 hay C99.

char arr[MAX_NUMBER_STRINGS][MAX_STRING_SIZE]; 
strcpy(arr[0], "blah");

Cập nhật: Thomas nói strlcpylà con đường để đi.

Dưới đây là một số tùy chọn của bạn:

char a1[][14] = { "blah", "hmm" };
char* a2[] = { "blah", "hmm" };
char (*a3[])[] = { &"blah", &"hmm" };  // only since you brought up the syntax -

printf(a1[0]); // prints blah
printf(a2[0]); // prints blah
printf(*a3[0]); // prints blah

Ưu điểm của a2là sau đó bạn có thể thực hiện các thao tác sau với chuỗi ký tự

a2[0] = "hmm";
a2[1] = "blah";

Và đối với a3bạn có thể làm như sau:

a3[0] = &"hmm";
a3[1] = &"blah";

Đối với a1bạn sẽ phải sử dụng strcpy()(tốt hơn nữa strncpy()) ngay cả khi gán chuỗi ký tự. Lý do là a2, và a3là các mảng của con trỏ và bạn có thể làm cho các phần tử của chúng (tức là con trỏ) trỏ đến bất kỳ bộ lưu trữ nào, trong khia1 là một mảng 'mảng ký tự' và vì vậy mỗi phần tử là một mảng "sở hữu" bộ lưu trữ của riêng nó ( có nghĩa là nó bị phá hủy khi đi ra khỏi phạm vi) - bạn chỉ có thể sao chép nội dung vào bộ lưu trữ của nó.

Điều này cũng mang đến cho chúng ta nhược điểm của việc sử dụng a2và a3- vì chúng trỏ đến lưu trữ tĩnh (nơi lưu trữ chuỗi ký tự), nội dung không thể thay đổi đáng tin cậy (viz. Hành vi không xác định), nếu bạn muốn gán các ký tự không phải chuỗi cho các yếu tố của a2hoặca3 - trước tiên bạn sẽ phải tự động phân bổ đủ bộ nhớ và sau đó các phần tử của chúng trỏ đến bộ nhớ này, sau đó sao chép các ký tự vào nó - và sau đó bạn phải chắc chắn phân bổ bộ nhớ khi hoàn tất.

Bah - tôi nhớ C ++ rồi;)

ps Hãy cho tôi biết nếu bạn cần ví dụ.

Hoặc bạn có thể khai báo một kiểu cấu trúc, chứa một ký tự arry (1 chuỗi), chúng tạo ra một mảng của các cấu trúc và do đó là một mảng nhiều phần tử

typedef struct name
{
   char name[100]; // 100 character array
}name;

main()
{
   name yourString[10]; // 10 strings
   printf("Enter something\n:);
   scanf("%s",yourString[0].name);
   scanf("%s",yourString[1].name);
   // maybe put a for loop and a few print ststements to simplify code
   // this is just for example 
 }

Một trong những lợi thế của điều này so với bất kỳ phương pháp nào khác là điều này cho phép bạn quét trực tiếp vào chuỗi mà không phải sử dụng strcpy;

Trong ANSI C:

char* strings[3];
strings[0] = "foo";
strings[1] = "bar";
strings[2] = "baz";

Nếu các chuỗi là tĩnh, tốt nhất bạn nên tắt:

const char *my_array[] = {"eenie","meenie","miney"};

Mặc dù không phải là một phần của ANSI C cơ bản, rất có thể môi trường của bạn hỗ trợ cú pháp. Các chuỗi này là bất biến (chỉ đọc) và do đó, trong nhiều môi trường sử dụng ít chi phí hơn là tự động xây dựng một chuỗi chuỗi.

Ví dụ, trong các dự án bộ điều khiển vi mô nhỏ, cú pháp này sử dụng bộ nhớ chương trình thay vì (thường) bộ nhớ ram quý hơn. AVR-C là một môi trường ví dụ hỗ trợ cú pháp này, nhưng hầu hết các môi trường khác cũng vậy.

Nếu bạn không muốn theo dõi số lượng chuỗi trong mảng và muốn lặp lại chúng, chỉ cần thêm chuỗi NULL vào cuối:

char *strings[]={ "one", "two", "three", NULL };

int i=0;
while(strings[i]) {
  printf("%s\n", strings[i]);
  //do something
  i++;
};

Các chuỗi ký tự là const char *s.

Và việc sử dụng dấu ngoặc đơn của bạn là số lẻ. Bạn có thể có nghĩa là

const char *a[2] = {"blah", "hmm"};

trong đó khai báo một mảng gồm hai con trỏ thành các ký tự không đổi và khởi tạo chúng để trỏ đến hai hằng chuỗi được mã hóa cứng.

Mã của bạn đang tạo ra một loạt các con trỏ hàm. Thử

char* a[size];

hoặc là

char a[size1][size2];

thay thế.

Xem wikibook để mảng và con trỏ

xin chào bạn có thể thử dưới đây:

 char arr[nb_of_string][max_string_length]; 
 strcpy(arr[0], "word");

một ví dụ hay về việc sử dụng, mảng các chuỗi trong c nếu bạn muốn

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


int main(int argc, char *argv[]){

int i, j, k;

// to set you array
//const arr[nb_of_string][max_string_length]
char array[3][100];

char temp[100];
char word[100];

for (i = 0; i < 3; i++){
    printf("type word %d : ",i+1);
    scanf("%s", word);
    strcpy(array[i], word);
}

for (k=0; k<3-1; k++){
    for (i=0; i<3-1; i++)
    {
        for (j=0; j<strlen(array[i]); j++)
        {
            // if a letter ascii code is bigger we swap values
            if (array[i][j] > array[i+1][j])
            {
                strcpy(temp, array[i+1]);
                strcpy(array[i+1], array[i]);
                strcpy(array[i], temp);

                j = 999;
            }

            // if a letter ascii code is smaller we stop
            if (array[i][j] < array[i+1][j])
            {
                    j = 999;
            }

        }
    }
}

for (i=0; i<3; i++)
{
    printf("%s\n",array[i]);
}

return 0;
}

char name[10][10]
int i,j,n;//here "n" is number of enteries
printf("\nEnter size of array = ");
scanf("%d",&n);
for(i=0;i<n;i++)
{
    for(j=0;j<1;j++)
    {
        printf("\nEnter name = ");
        scanf("%s",&name[i]);
    }
}
//printing the data
for(i=0;i<n;i++)
{
    for(j=0;j<1;j++)
    {
        printf("%d\t|\t%s\t|\t%s",rollno[i][j],name[i],sex[i]);
    }
    printf("\n");
}

Ở đây thử cái này !!!

Tôi đã thiếu một chuỗi các chuỗi động hơn, trong đó số lượng chuỗi có thể thay đổi tùy theo lựa chọn thời gian chạy, nhưng nếu không thì các chuỗi phải được sửa.

Tôi đã kết thúc đoạn mã mã như thế này:

#define INIT_STRING_ARRAY(...)          \
    {                                   \
        char* args[] = __VA_ARGS__;     \
        ev = args;                      \
        count = _countof(args);         \
    }

void InitEnumIfAny(String& key, CMFCPropertyGridProperty* item)
{
    USES_CONVERSION;
    char** ev = nullptr;
    int count = 0;

    if( key.Compare("horizontal_alignment") )
        INIT_STRING_ARRAY( { "top", "bottom" } )

    if (key.Compare("boolean"))
        INIT_STRING_ARRAY( { "yes", "no" } )

    if( ev == nullptr )
        return;

    for( int i = 0; i < count; i++)
        item->AddOption(A2T(ev[i]));

    item->AllowEdit(FALSE);
}

char** evchọn con trỏ tới các chuỗi mảng và đếm số lượng chuỗi sử dụng _countofhàm. (Tương tự sizeof(arr) / sizeof(arr[0])).

Và có thêm Ansi để chuyển đổi unicode bằng A2Tmacro, nhưng đó có thể là tùy chọn cho trường hợp của bạn.

Một cách tốt là xác định một chuỗi tự của bạn.

#include <stdio.h>
typedef char string[]
int main() {
    string test = "string";
    return 0;
}

Nó thực sự đơn giản.