Lý do cho các chuỗi kết thúc null là gì?

Nhiều như tôi yêu C và C ++, tôi không thể không gãi đầu khi lựa chọn các chuỗi kết thúc null:

• Các chuỗi có tiền tố (ví dụ Pascal) tồn tại trước C
• Các chuỗi tiền tố có độ dài làm cho một số thuật toán nhanh hơn bằng cách cho phép tra cứu độ dài thời gian không đổi.
• Các chuỗi tiền tố có độ dài làm cho việc gây ra lỗi tràn bộ đệm trở nên khó khăn hơn.
• Ngay cả trên máy 32 bit, nếu bạn cho phép chuỗi có kích thước của bộ nhớ khả dụng, chuỗi có tiền tố dài chỉ rộng hơn ba byte so với chuỗi kết thúc null. Trên máy 16 bit, đây là một byte đơn. Trên các máy 64 bit, 4GB là giới hạn độ dài chuỗi hợp lý, nhưng ngay cả khi bạn muốn mở rộng nó thành kích thước của từ máy, máy 64 bit thường có bộ nhớ rộng làm cho thêm bảy byte đối số null. Tôi biết tiêu chuẩn C ban đầu được viết cho các máy cực kỳ kém (về bộ nhớ), nhưng đối số hiệu quả không bán cho tôi ở đây.
• Khá nhiều ngôn ngữ khác (ví dụ Perl, Pascal, Python, Java, C #, v.v.) sử dụng các chuỗi có tiền tố dài. Các ngôn ngữ này thường đánh bại C trong các điểm chuẩn thao tác chuỗi vì chúng hiệu quả hơn với chuỗi.
• C ++ đã sửa lỗi này một chút với std::basic_stringkhuôn mẫu, nhưng các mảng ký tự đơn giản mong đợi các chuỗi kết thúc null vẫn còn phổ biến. Điều này cũng không hoàn hảo bởi vì nó đòi hỏi phân bổ heap.
• Các chuỗi kết thúc không phải dự trữ một ký tự (cụ thể là null), không thể tồn tại trong chuỗi, trong khi các chuỗi có tiền tố dài có thể chứa các null được nhúng.

Một vài trong số những điều này đã được đưa ra ánh sáng gần đây hơn C, vì vậy sẽ có ý nghĩa đối với C khi không biết về chúng. Tuy nhiên, một số đơn giản là tốt trước khi C đến. Tại sao các chuỗi kết thúc null được chọn thay vì tiền tố chiều dài rõ ràng vượt trội?

EDIT : Vì một số người hỏi về sự thật (và không giống như những gì tôi đã cung cấp) về điểm hiệu quả của tôi ở trên, chúng xuất phát từ một số điều:

• Việc sử dụng chuỗi kết thúc null yêu cầu độ phức tạp thời gian O (n + m). Tiền tố độ dài thường chỉ yêu cầu O (m).
• Độ dài sử dụng chuỗi kết thúc null yêu cầu độ phức tạp thời gian O (n). Tiền tố độ dài là O (1).
• Chiều dài và concat là các hoạt động chuỗi phổ biến nhất. Có một số trường hợp chuỗi kết thúc null có thể hiệu quả hơn, nhưng những điều này xảy ra ít thường xuyên hơn.

Từ các câu trả lời dưới đây, đây là một số trường hợp chuỗi kết thúc null hiệu quả hơn:

• Khi bạn cần cắt bỏ phần bắt đầu của một chuỗi và cần chuyển nó sang một phương thức nào đó. Bạn thực sự không thể làm điều này trong thời gian liên tục với tiền tố độ dài ngay cả khi bạn được phép hủy chuỗi gốc, bởi vì tiền tố độ dài có thể cần phải tuân theo quy tắc căn chỉnh.
• Trong một số trường hợp khi bạn chỉ lặp qua ký tự chuỗi theo ký tự, bạn có thể lưu thanh ghi CPU. Lưu ý rằng điều này chỉ hoạt động trong trường hợp bạn chưa phân bổ động chuỗi (Vì sau đó bạn phải giải phóng nó, bắt buộc phải sử dụng thanh ghi CPU mà bạn đã lưu để giữ con trỏ ban đầu bạn có được từ malloc và bạn bè).

Không có cái nào ở trên gần như phổ biến như chiều dài và concat.

Có thêm một câu khẳng định trong các câu trả lời dưới đây:

• Bạn cần cắt bỏ phần cuối của chuỗi

nhưng điều này là không chính xác - đó là cùng một khoảng thời gian cho các chuỗi tiền tố kết thúc và độ dài null. (Các chuỗi kết thúc không có chỉ là một null trong đó bạn muốn kết thúc mới, các tiền tố có độ dài chỉ trừ đi tiền tố.)

Từ miệng ngựa

Không có BCPL, B hoặc C nào hỗ trợ dữ liệu ký tự mạnh mẽ bằng ngôn ngữ; mỗi chuỗi xử lý các chuỗi giống như các vectơ của số nguyên và bổ sung các quy tắc chung bằng một vài quy ước. Trong cả BCPL và B, một chuỗi ký tự biểu thị địa chỉ của một vùng tĩnh được khởi tạo với các ký tự của chuỗi, được đóng gói vào các ô. Trong BCPL, byte được đóng gói đầu tiên chứa số lượng ký tự trong chuỗi; trong B, không có số đếm và chuỗi được kết thúc bởi một ký tự đặc biệt, mà B đánh vần *e. Thay đổi này được thực hiện một phần để tránh giới hạn về độ dài của chuỗi gây ra bằng cách giữ số đếm trong khe 8- hoặc 9 bit, và một phần vì việc duy trì số đếm dường như, theo kinh nghiệm của chúng tôi, ít thuận tiện hơn so với sử dụng bộ kết thúc.

_{Dennis M Ritchie, Phát triển ngôn ngữ C}

C không có một chuỗi như một phần của ngôn ngữ. Một "chuỗi" trong C chỉ là một con trỏ tới char. Vì vậy, có thể bạn đang hỏi sai câu hỏi.

"Lý do để loại bỏ một loại chuỗi" có thể phù hợp hơn. Tôi chỉ ra rằng C không phải là ngôn ngữ hướng đối tượng và chỉ có các loại giá trị cơ bản. Chuỗi là một khái niệm cấp cao hơn phải được thực hiện bằng một cách nào đó kết hợp các giá trị của các loại khác. C ở mức độ trừu tượng thấp hơn.

trong ánh sáng của cơn giận dữ bên dưới:

Tôi chỉ muốn chỉ ra rằng tôi không cố nói đây là một câu hỏi ngu ngốc hay xấu, hay cách biểu diễn chuỗi C là lựa chọn tốt nhất. Tôi đang cố gắng làm rõ rằng câu hỏi sẽ được đặt ngắn gọn hơn nếu bạn tính đến thực tế là C không có cơ chế để phân biệt một chuỗi như một kiểu dữ liệu từ một mảng byte. Đây có phải là sự lựa chọn tốt nhất trong khả năng xử lý và bộ nhớ của máy tính ngày nay? Chắc là không. Nhưng nhận thức muộn luôn là 20/20 và tất cả những thứ đó :)

Câu hỏi được hỏi như một điều Length Prefixed Strings (LPS)so với zero terminated strings (SZ)điều, nhưng chủ yếu là phơi bày lợi ích của các chuỗi tiền tố dài. Điều đó có vẻ quá sức, nhưng thành thật mà nói, chúng ta cũng nên xem xét những hạn chế của LPS và lợi thế của SZ.

Theo tôi hiểu, câu hỏi thậm chí có thể được hiểu là một cách thiên vị để hỏi "những lợi thế của Chuỗi không kết thúc là gì?".

Ưu điểm (tôi thấy) của Chuỗi không kết thúc:

• Rất đơn giản, không cần phải giới thiệu các khái niệm mới trong ngôn ngữ, mảng char / con trỏ char có thể làm được.
• ngôn ngữ cốt lõi chỉ bao gồm đường cú pháp tối thiểu để chuyển đổi một cái gì đó giữa dấu ngoặc kép thành một bó ký tự (thực sự là một bó byte). Trong một số trường hợp, nó có thể được sử dụng để khởi tạo những thứ hoàn toàn không liên quan đến văn bản. Ví dụ, định dạng tệp hình ảnh xpm là nguồn C hợp lệ chứa dữ liệu hình ảnh được mã hóa dưới dạng chuỗi.
• Nhân tiện, bạn có thể đặt số 0 trong một chuỗi ký tự, trình biên dịch cũng sẽ thêm một số khác ở cuối chữ : "this\0is\0valid\0C". Có phải là một chuỗi? hoặc bốn chuỗi? Hoặc một loạt các byte ...
• thực hiện bằng phẳng, không có ẩn số, không có số nguyên ẩn.
• không có phân bổ bộ nhớ ẩn liên quan (tốt, một số chức năng phi tiêu chuẩn khét tiếng như strdup thực hiện phân bổ, nhưng đó chủ yếu là một vấn đề).
• không có vấn đề cụ thể nào đối với phần cứng nhỏ hay lớn (hãy tưởng tượng gánh nặng quản lý độ dài tiền tố 32 bit trên bộ vi điều khiển 8 bit hoặc hạn chế kích thước chuỗi xuống dưới 256 byte, đó là vấn đề tôi thực sự gặp phải với Turbo Pascal trước đây).
• thực hiện thao tác chuỗi chỉ là một số ít chức năng thư viện rất đơn giản
• hiệu quả cho việc sử dụng chính của chuỗi: văn bản không đổi đọc tuần tự từ một khởi đầu đã biết (chủ yếu là tin nhắn cho người dùng).
• số 0 kết thúc thậm chí không bắt buộc, tất cả các công cụ cần thiết để thao tác ký tự như một bó byte có sẵn. Khi thực hiện khởi tạo mảng trong C, bạn thậm chí có thể tránh được đầu cuối NUL. Chỉ cần đặt đúng kích thước. char a[3] = "foo";là C hợp lệ (không phải C ++) và sẽ không đặt số 0 cuối cùng vào a.
• phù hợp với quan điểm unix "mọi thứ đều là tệp", bao gồm cả "tệp" không có chiều dài nội tại như stdin, stdout. Bạn nên nhớ rằng các nguyên thủy đọc và viết mở được thực hiện ở mức rất thấp. Chúng không phải là các cuộc gọi thư viện, mà là các cuộc gọi hệ thống. Và cùng một API được sử dụng cho các tệp nhị phân hoặc văn bản. Các tệp gốc đọc tệp có được một địa chỉ bộ đệm và kích thước và trả về kích thước mới. Và bạn có thể sử dụng chuỗi làm bộ đệm để viết. Sử dụng một kiểu biểu diễn chuỗi khác có nghĩa là bạn không thể dễ dàng sử dụng một chuỗi ký tự làm bộ đệm để xuất ra, hoặc bạn sẽ phải làm cho nó có một hành vi rất lạ khi truyền nó char*. Cụ thể là không trả về địa chỉ của chuỗi, mà thay vào đó là trả về dữ liệu thực tế.
• rất dễ dàng để thao tác dữ liệu văn bản được đọc từ một tệp tại chỗ, không có bản sao bộ đệm vô dụng, chỉ cần chèn các số 0 ở đúng vị trí bộ phận).
• chuẩn bị một số giá trị int ở bất kỳ kích thước nào sẽ bao hàm các vấn đề căn chỉnh. Độ dài ban đầu phải được căn chỉnh, nhưng không có lý do gì để làm điều đó cho các dữ liệu ký tự (và một lần nữa, việc buộc các chuỗi sẽ ngụ ý các vấn đề khi coi chúng là một bó byte).
• độ dài được biết đến tại thời gian biên dịch cho chuỗi ký tự không đổi (sizeof). Vậy tại sao bất cứ ai cũng muốn lưu trữ nó trong bộ nhớ chuẩn bị nó vào dữ liệu thực tế?
• theo cách mà C đang làm (gần như) mọi người khác, các chuỗi được xem như là mảng của char. Vì độ dài mảng không được quản lý bởi C, nên độ dài logic không được quản lý cho chuỗi. Điều đáng ngạc nhiên duy nhất là 0 mục được thêm vào cuối, nhưng đó chỉ ở cấp độ ngôn ngữ cốt lõi khi nhập một chuỗi giữa các dấu ngoặc kép. Người dùng hoàn toàn có thể gọi các hàm thao tác chuỗi đi qua chiều dài hoặc thậm chí sử dụng bản ghi nhớ đơn giản để thay thế. SZ chỉ là một cơ sở. Trong hầu hết các ngôn ngữ khác, độ dài mảng được quản lý, logic của nó giống với các chuỗi.
• trong thời hiện đại, dù sao thì bộ ký tự 1 byte là không đủ và bạn thường phải xử lý các chuỗi unicode được mã hóa trong đó số lượng ký tự rất khác nhau về số lượng byte. Nó ngụ ý rằng người dùng có thể sẽ muốn nhiều hơn "chỉ kích thước", mà còn các thông tin khác. Giữ độ dài không sử dụng gì (đặc biệt là không có nơi tự nhiên để lưu trữ chúng) liên quan đến những thông tin hữu ích khác này.

Điều đó nói rằng, không cần phải phàn nàn trong trường hợp hiếm hoi khi chuỗi C tiêu chuẩn thực sự không hiệu quả. Libs có sẵn. Nếu tôi theo xu hướng đó, tôi nên phàn nàn rằng tiêu chuẩn C không bao gồm bất kỳ chức năng hỗ trợ regex nào ... nhưng thực sự mọi người đều biết đó không phải là vấn đề thực sự vì có thư viện cho mục đích đó. Vì vậy, khi muốn hiệu quả thao tác chuỗi, tại sao không sử dụng một thư viện như chuỗi ? Hoặc thậm chí chuỗi C ++?

EDIT : Gần đây tôi đã có một cái nhìn để D chuỗi . Thật thú vị khi thấy rằng giải pháp được chọn không phải là tiền tố kích thước, cũng không phải là chấm dứt. Như trong C, các chuỗi ký tự được đặt trong dấu ngoặc kép chỉ là viết tắt của các mảng char bất biến và ngôn ngữ cũng có một chuỗi từ khóa có nghĩa là (mảng char bất biến).

Nhưng mảng D phong phú hơn nhiều so với mảng C. Trong trường hợp độ dài mảng tĩnh được biết đến trong thời gian chạy nên không cần lưu trữ độ dài. Trình biên dịch có nó tại thời gian biên dịch. Trong trường hợp mảng động, chiều dài có sẵn nhưng tài liệu D không nêu rõ nơi lưu giữ. Đối với tất cả những gì chúng ta biết, trình biên dịch có thể chọn giữ nó trong một số thanh ghi hoặc trong một số biến được lưu trữ cách xa dữ liệu ký tự.

Trên các mảng char bình thường hoặc các chuỗi không có nghĩa đen, không có số 0 cuối cùng, do đó, lập trình viên phải tự đặt nó nếu anh ta muốn gọi một số hàm C từ D. Trong trường hợp cụ thể của các chuỗi ký tự, tuy nhiên trình biên dịch D vẫn đặt số 0 ở kết thúc mỗi chuỗi (để cho phép truyền dễ dàng tới chuỗi C để gọi hàm C dễ dàng hơn?), nhưng số 0 này không phải là một phần của chuỗi (D không tính nó theo kích thước chuỗi).

Điều duy nhất làm tôi thất vọng phần nào là các chuỗi được cho là utf-8, nhưng độ dài rõ ràng vẫn trả về một số byte (ít nhất là đúng trên trình biên dịch gdc của tôi) ngay cả khi sử dụng ký tự nhiều byte. Tôi không rõ là do lỗi biên dịch hay do mục đích. (OK, tôi có thể đã tìm ra điều gì đã xảy ra. Để nói với trình biên dịch D, nguồn của bạn sử dụng utf-8, bạn phải đặt một số thứ tự byte ngu ngốc ngay từ đầu. Tôi viết ngu ngốc vì tôi không biết trình soạn thảo làm điều đó, đặc biệt là cho UTF- 8 được cho là tương thích ASCII).

Tôi nghĩ rằng, nó có lý do lịch sử và tìm thấy điều này trong wikipedia :

Tại thời điểm C (và các ngôn ngữ mà nó được tạo ra) được phát triển, bộ nhớ cực kỳ hạn chế, vì vậy chỉ sử dụng một byte phí để lưu trữ độ dài của chuỗi là hấp dẫn. Sự thay thế phổ biến duy nhất tại thời điểm đó, thường được gọi là "chuỗi Pascal" (mặc dù cũng được sử dụng bởi các phiên bản đầu tiên của BASIC), đã sử dụng một byte hàng đầu để lưu trữ độ dài của chuỗi. Điều này cho phép chuỗi chứa NUL và thực hiện tìm độ dài chỉ cần một lần truy cập bộ nhớ (O (1) (không đổi) thời gian). Nhưng một byte giới hạn độ dài là 255. Giới hạn độ dài này hạn chế hơn nhiều so với các vấn đề với chuỗi C, do đó, chuỗi C nói chung đã thắng.

Calavera là đúng , nhưng khi mọi người dường như không có được quan điểm của mình, tôi sẽ cung cấp một số ví dụ mã.

Trước tiên, hãy xem xét C là gì: một ngôn ngữ đơn giản, trong đó tất cả các mã có một bản dịch trực tiếp khá thành ngôn ngữ máy. Tất cả các loại phù hợp với các thanh ghi và trên ngăn xếp, và nó không yêu cầu một hệ điều hành hoặc một thư viện thời gian lớn để chạy, vì nó có nghĩa là viết những điều này (một nhiệm vụ rất phù hợp, xem xét ở đó thậm chí không phải là một đối thủ cạnh tranh cho đến ngày nay).

Nếu C có một stringloại, như inthoặc char, thì đó sẽ là loại không phù hợp với thanh ghi hoặc trong ngăn xếp và sẽ yêu cầu cấp phát bộ nhớ (với tất cả cơ sở hạ tầng hỗ trợ) theo bất kỳ cách nào. Tất cả đều đi ngược lại các nguyên lý cơ bản của C.

Vì vậy, một chuỗi trong C là:

char s*;

Vì vậy, hãy giả sử rằng đây là tiền tố dài. Hãy viết mã để nối hai chuỗi:

char* concat(char* s1, char* s2)
{
    /* What? What is the type of the length of the string? */
    int l1 = *(int*) s1;
    /* How much? How much must I skip? */
    char *s1s = s1 + sizeof(int);
    int l2 = *(int*) s2;
    char *s2s = s2 + sizeof(int);
    int l3 = l1 + l2;
    char *s3 = (char*) malloc(l3 + sizeof(int));
    char *s3s = s3 + sizeof(int);
    memcpy(s3s, s1s, l1);
    memcpy(s3s + l1, s2s, l2);
    *(int*) s3 = l3;
    return s3;
}

Một cách khác là sử dụng struct để xác định chuỗi:

struct {
  int len; /* cannot be left implementation-defined */
  char* buf;
}

Tại thời điểm này, tất cả các thao tác chuỗi sẽ yêu cầu hai phân bổ được thực hiện, trong thực tế, điều đó có nghĩa là bạn sẽ đi qua một thư viện để thực hiện bất kỳ xử lý nào.

Điều buồn cười là ... những cấu trúc như thế tồn tại trong C! Chúng chỉ không được sử dụng để hiển thị tin nhắn hàng ngày của bạn cho người dùng xử lý.

Vì vậy, đây là điểm Calavera đang thực hiện: không có loại chuỗi trong C . Để làm bất cứ điều gì với nó, bạn phải lấy một con trỏ và giải mã nó thành một con trỏ thành hai loại khác nhau, và sau đó nó trở nên rất phù hợp với kích thước của một chuỗi và không thể chỉ là "xác định thực hiện".

Bây giờ, C có thể xử lý bộ nhớ bằng mọi cách và các memhàm trong thư viện (trong <string.h>, thậm chí!) Cung cấp tất cả các công cụ bạn cần để xử lý bộ nhớ dưới dạng một cặp con trỏ và kích thước. Cái gọi là "chuỗi" trong C được tạo ra chỉ với một mục đích: hiển thị các thông báo trong bối cảnh viết một hệ điều hành dành cho các thiết bị đầu cuối văn bản. Và, cho điều đó, chấm dứt null là đủ.

Rõ ràng về hiệu suất và an toàn, bạn sẽ muốn giữ độ dài của chuỗi trong khi bạn làm việc với chuỗi đó thay vì liên tục thực hiện strlenhoặc tương đương với chuỗi đó. Tuy nhiên, lưu trữ độ dài ở một vị trí cố định ngay trước nội dung chuỗi là một thiết kế cực kỳ tệ. Như Jorgen đã chỉ ra trong các nhận xét về câu trả lời của Sanjit, nó loại trừ việc xử lý phần đuôi của chuỗi như một chuỗi, ví dụ, thực hiện rất nhiều thao tác phổ biến như path_to_filenamehoặc filename_to_extensionkhông thể mà không phân bổ bộ nhớ mới (và phát sinh khả năng thất bại và xử lý lỗi) . Và dĩ nhiên, có một vấn đề là không ai có thể đồng ý trường có độ dài chuỗi nên chiếm bao nhiêu byte (rất nhiều "chuỗi Pascal" xấu

Thiết kế của C cho phép lập trình viên chọn nếu / ở đâu / cách lưu trữ độ dài linh hoạt và mạnh mẽ hơn nhiều. Nhưng tất nhiên các lập trình viên phải thông minh. C trừng phạt sự ngu ngốc với các chương trình bị sập, ngừng hoạt động hoặc cho kẻ thù của bạn root.

Sự lười biếng, đăng ký tính tiết kiệm và tính di động khi xem xét việc lắp ráp của bất kỳ ngôn ngữ nào, đặc biệt là C, một bước so với lắp ráp (do đó thừa hưởng rất nhiều mã kế thừa lắp ráp). Bạn sẽ đồng ý vì một char null sẽ vô dụng trong những ngày ASCII đó, nó (và có lẽ tốt như char char kiểm soát EOF).

Hãy xem mã giả

function readString(string) // 1 parameter: 1 register or 1 stact entries
    pointer=addressOf(string) 
    while(string[pointer]!=CONTROL_CHAR) do
        read(string[pointer])
        increment pointer

tổng số 1 đăng ký sử dụng

trường hợp 2

 function readString(length,string) // 2 parameters: 2 register used or 2 stack entries
     pointer=addressOf(string) 
     while(length>0) do 
         read(string[pointer])
         increment pointer
         decrement length

tổng số 2 thanh ghi được sử dụng

Điều đó có vẻ thiển cận vào thời điểm đó, nhưng xem xét tính tiết kiệm trong mã và đăng ký (đó là PREMIUM tại thời điểm đó, thời điểm bạn biết, họ sử dụng thẻ đục lỗ). Do đó nhanh hơn (khi tốc độ bộ xử lý có thể được tính bằng kHz), "Hack" này khá tốt và dễ mang theo bộ xử lý không đăng ký một cách dễ dàng.

Để tranh luận, tôi sẽ thực hiện 2 thao tác chuỗi chung

stringLength(string)
     pointer=addressOf(string)
     while(string[pointer]!=CONTROL_CHAR) do
         increment pointer
     return pointer-addressOf(string)

độ phức tạp O (n) trong hầu hết các trường hợp chuỗi PASCAL là O (1) vì độ dài của chuỗi được đặt trước vào cấu trúc chuỗi (điều đó cũng có nghĩa là thao tác này sẽ phải được thực hiện trong giai đoạn trước).

concatString(string1,string2)
     length1=stringLength(string1)
     length2=stringLength(string2)
     string3=allocate(string1+string2)
     pointer1=addressOf(string1)
     pointer3=addressOf(string3)
     while(string1[pointer1]!=CONTROL_CHAR) do
         string3[pointer3]=string1[pointer1]
         increment pointer3
         increment pointer1
     pointer2=addressOf(string2)
     while(string2[pointer2]!=CONTROL_CHAR) do
         string3[pointer3]=string2[pointer2]
         increment pointer3
         increment pointer1
     return string3

độ phức tạp O (n) và chuẩn bị độ dài chuỗi sẽ không thay đổi độ phức tạp của thao tác, trong khi tôi thừa nhận sẽ mất ít thời gian hơn 3 lần.

Mặt khác, nếu bạn sử dụng chuỗi PASCAL, bạn sẽ phải thiết kế lại API của mình để lấy chiều dài đăng ký tài khoản và độ bền bit, chuỗi PASCAL có giới hạn nổi tiếng là 255 char (0xFF) vì độ dài được lưu trữ trong 1 byte (8 bit) ) và bạn muốn có một chuỗi dài hơn (16 bit-> bất cứ thứ gì) bạn sẽ phải tính đến kiến ​​trúc trong một lớp mã của mình, điều đó có nghĩa là trong hầu hết các API chuỗi không tương thích trong trường hợp nếu bạn muốn chuỗi dài hơn.

Thí dụ:

Một tệp được viết bằng chuỗi api được chuẩn bị trước của bạn trên máy tính 8 bit và sau đó sẽ phải đọc trên máy tính 32 bit, chương trình lười biếng sẽ xem xét rằng 4byte của bạn là độ dài của chuỗi sau đó phân bổ số lượng bộ nhớ đó như thế nào sau đó cố gắng đọc nhiều byte đó. Một trường hợp khác sẽ là chuỗi PPC 32 byte đọc (endian nhỏ) trên x86 (endian lớn), tất nhiên nếu bạn không biết rằng cái này được viết bởi cái kia thì sẽ có rắc rối. Độ dài 1 byte (0x00000001) sẽ trở thành 16777216 (0x0100000) là 16 MB để đọc chuỗi 1 byte. Tất nhiên bạn sẽ nói rằng mọi người nên đồng ý về một tiêu chuẩn nhưng ngay cả unicode 16 bit cũng có độ bền nhỏ và lớn.

Tất nhiên C cũng có vấn đề của nó, nhưng, sẽ rất ít bị ảnh hưởng bởi các vấn đề được nêu ra ở đây.

Theo nhiều cách, C là nguyên thủy. Và tôi yêu nó.

Đó là một bước trên ngôn ngữ lắp ráp, mang lại cho bạn hiệu suất gần như tương tự với ngôn ngữ dễ viết và duy trì hơn nhiều.

Bộ kết thúc null đơn giản và không yêu cầu sự hỗ trợ đặc biệt của ngôn ngữ.

Nhìn lại, có vẻ không thuận tiện. Nhưng tôi đã sử dụng ngôn ngữ lắp ráp từ những năm 80 và nó có vẻ rất thuận tiện vào thời điểm đó. Tôi chỉ nghĩ rằng phần mềm liên tục phát triển, và các nền tảng và công cụ liên tục ngày càng tinh vi hơn.

Giả sử trong giây lát C đã triển khai chuỗi theo cách Pascal, bằng cách thêm tiền tố vào chúng theo chiều dài: chuỗi dài 7 char có phải là DATA TYPE giống như chuỗi 3 char không? Nếu câu trả lời là có, thì trình biên dịch sẽ tạo ra loại mã nào khi tôi gán cái trước cho cái sau? Chuỗi nên được cắt ngắn, hoặc tự động thay đổi kích thước? Nếu thay đổi kích thước, thao tác đó có nên được bảo vệ bằng khóa để làm cho nó an toàn không? Phương pháp tiếp cận C đã đẩy tất cả những vấn đề này, dù muốn hay không :)

Bằng cách nào đó tôi đã hiểu câu hỏi để ngụ ý rằng không có trình biên dịch hỗ trợ cho các chuỗi có tiền tố dài trong C. Ví dụ sau đây cho thấy, ít nhất bạn có thể bắt đầu thư viện chuỗi C của riêng mình, trong đó độ dài chuỗi được tính vào thời gian biên dịch, với cấu trúc như sau:

#define PREFIX_STR(s) ((prefix_str_t){ sizeof(s)-1, (s) })

typedef struct { int n; char * p; } prefix_str_t;

int main() {
    prefix_str_t string1, string2;

    string1 = PREFIX_STR("Hello!");
    string2 = PREFIX_STR("Allows \0 chars (even if printf directly doesn't)");

    printf("%d %s\n", string1.n, string1.p); /* prints: "6 Hello!" */
    printf("%d %s\n", string2.n, string2.p); /* prints: "48 Allows " */

    return 0;
}

Tuy nhiên, điều này sẽ không có vấn đề gì vì bạn cần cẩn thận khi giải phóng cụ thể con trỏ chuỗi đó và khi nào nó được phân bổ tĩnh ( charmảng bằng chữ ).

Chỉnh sửa: Là câu trả lời trực tiếp hơn cho câu hỏi, quan điểm của tôi là đây là cách C có thể hỗ trợ cả việc có sẵn độ dài chuỗi (dưới dạng hằng số thời gian biên dịch), nếu bạn cần, nhưng vẫn không có phí bộ nhớ nếu bạn muốn sử dụng con trỏ chỉ và chấm dứt bằng không.

Tất nhiên, có vẻ như làm việc với các chuỗi kết thúc bằng 0 là cách làm được khuyến nghị, vì nói chung thư viện tiêu chuẩn không lấy độ dài chuỗi làm đối số và vì việc trích xuất độ dài không phải là mã đơn giản char * s = "abc"như ví dụ của tôi cho thấy.

"Ngay cả trên máy 32 bit, nếu bạn cho phép chuỗi có kích thước của bộ nhớ khả dụng, chuỗi có tiền tố dài chỉ rộng hơn ba byte so với chuỗi kết thúc null."

Đầu tiên, thêm 3 byte có thể là chi phí đáng kể cho các chuỗi ngắn. Đặc biệt, một chuỗi có độ dài bằng không bây giờ chiếm gấp 4 lần bộ nhớ. Một số người trong chúng ta đang sử dụng máy 64 bit, vì vậy chúng tôi cần 8 byte để lưu trữ chuỗi có độ dài bằng 0 hoặc định dạng chuỗi không thể đối phó với chuỗi dài nhất mà nền tảng hỗ trợ.

Cũng có thể có vấn đề liên kết để giải quyết. Giả sử tôi có một khối bộ nhớ chứa 7 chuỗi, như "solo \ 0second \ 0 \ 0four \ 0five \ 0 \ 0seventh". Chuỗi thứ hai bắt đầu ở offset 5. Phần cứng có thể yêu cầu các số nguyên 32 bit được căn chỉnh tại một địa chỉ là bội số của 4, vì vậy bạn phải thêm phần đệm, tăng thêm chi phí. Các đại diện C là rất hiệu quả bộ nhớ trong so sánh. (Hiệu quả bộ nhớ là tốt; chẳng hạn, nó giúp hiệu năng bộ nhớ cache.)

Việc chấm dứt null cho phép các hoạt động dựa trên con trỏ nhanh.

Một điểm chưa được đề cập: khi C được thiết kế, có nhiều máy mà 'char' không phải là tám bit (thậm chí ngày nay còn có các nền tảng DSP không có). Nếu một người quyết định rằng các chuỗi phải có tiền tố độ dài, thì nên sử dụng bao nhiêu tiền tố có độ dài char? Sử dụng hai sẽ áp đặt giới hạn nhân tạo cho độ dài chuỗi cho các máy có không gian địa chỉ char 8 bit và 32 bit, trong khi lãng phí không gian trên các máy có char 16 bit và không gian địa chỉ 16 bit.

Nếu người ta muốn cho phép các chuỗi có độ dài tùy ý được lưu trữ hiệu quả và nếu 'char' luôn là 8 bit, thì người ta có thể - với một số chi phí về tốc độ và kích thước mã - xác định một sơ đồ là một chuỗi có tiền tố N sẽ dài N / 2 byte, một chuỗi có tiền tố N và giá trị chẵn M (đọc ngược) có thể là ((N-1) + M * char_max) / 2, v.v. và yêu cầu bất kỳ bộ đệm nào yêu cầu cung cấp một lượng không gian nhất định để giữ một chuỗi phải cho phép đủ byte trước không gian đó để xử lý độ dài tối đa. Tuy nhiên, thực tế là 'char' không phải lúc nào cũng 8 bit, sẽ làm phức tạp một sơ đồ như vậy, vì số lượng 'char' được yêu cầu để giữ độ dài của chuỗi sẽ thay đổi tùy theo kiến ​​trúc CPU.

Nhiều quyết định thiết kế xung quanh C xuất phát từ thực tế là khi nó được thực hiện ban đầu, việc truyền tham số có phần tốn kém. Đưa ra lựa chọn giữa ví dụ

void add_element_to_next(arr, offset)
  char[] arr;
  int offset;
{
  arr[offset] += arr[offset+1];
}

char array[40];

void test()
{
  for (i=0; i<39; i++)
    add_element_to_next(array, i);
}

đấu với

void add_element_to_next(ptr)
  char *p;
{
  p[0]+=p[1];
}

char array[40];

void test()
{
  int i;
  for (i=0; i<39; i++)
    add_element_to_next(arr+i);
}

cái sau sẽ rẻ hơn một chút (và do đó được ưa thích) vì nó chỉ yêu cầu truyền một tham số chứ không phải hai. Nếu phương thức được gọi không cần biết địa chỉ cơ sở của mảng cũng như chỉ mục bên trong nó, việc truyền một con trỏ kết hợp cả hai sẽ rẻ hơn so với việc chuyển các giá trị riêng rẽ.

Mặc dù có nhiều cách hợp lý để C có thể mã hóa độ dài chuỗi, các cách tiếp cận đã được phát minh cho đến thời điểm đó sẽ có tất cả các hàm bắt buộc có thể hoạt động với một phần của chuỗi để chấp nhận địa chỉ cơ sở của chuỗi và chỉ số mong muốn là hai tham số riêng biệt. Sử dụng kết thúc bằng 0 byte giúp tránh yêu cầu đó. Mặc dù các cách tiếp cận khác sẽ tốt hơn với các máy hiện nay (trình biên dịch hiện đại thường truyền tham số trong các thanh ghi và memcpy có thể được tối ưu hóa theo cách strcpy () - tương đương không thể) đủ mã sản xuất sử dụng các chuỗi kết thúc bằng 0 byte mà khó có thể thay đổi thành bất kỳ thứ gì khác.

PS - Để đổi lấy một hình phạt tốc độ nhẹ đối với một số thao tác và một chút chi phí phụ trên chuỗi dài hơn, có thể có các phương thức hoạt động với chuỗi chấp nhận con trỏ trực tiếp đến chuỗi, bộ đệm chuỗi được kiểm tra giới hạn hoặc cấu trúc dữ liệu xác định các chuỗi con của một chuỗi khác. Một hàm như "strcat" sẽ trông giống như [cú pháp hiện đại]

void strcat(unsigned char *dest, unsigned char *src)
{
  struct STRING_INFO d,s;
  str_size_t copy_length;

  get_string_info(&d, dest);
  get_string_info(&s, src);
  if (d.si_buff_size > d.si_length) // Destination is resizable buffer
  {
    copy_length = d.si_buff_size - d.si_length;
    if (s.src_length < copy_length)
      copy_length = s.src_length;
    memcpy(d.buff + d.si_length, s.buff, copy_length);
    d.si_length += copy_length;
    update_string_length(&d);
  }
}

Lớn hơn một chút so với phương pháp strcat K & R, nhưng nó sẽ hỗ trợ kiểm tra giới hạn, điều mà phương pháp K & R không có. Hơn nữa, không giống như phương thức hiện tại, có thể dễ dàng nối một chuỗi con tùy ý, ví dụ:

/* Concatenate 10th through 24th characters from src to dest */

void catpart(unsigned char *dest, unsigned char *src)
{
  struct SUBSTRING_INFO *inf;
  src = temp_substring(&inf, src, 10, 24);
  strcat(dest, src);
}

Lưu ý rằng thời gian tồn tại của chuỗi được trả về bởi temp_sub chuỗi sẽ bị giới hạn bởi các chuỗi svà src, bao giờ ngắn hơn (đó là lý do tại sao phương thức yêu cầu infđược truyền vào - nếu là cục bộ, nó sẽ chết khi phương thức được trả về).

Về chi phí bộ nhớ, các chuỗi và bộ đệm lên đến 64 byte sẽ có một byte trên không (giống như các chuỗi kết thúc bằng 0); các chuỗi dài hơn sẽ có nhiều hơn một chút (cho dù một lượng cho phép giữa hai byte và mức tối đa được yêu cầu sẽ là sự đánh đổi thời gian / không gian). Một giá trị đặc biệt của byte độ dài / chế độ sẽ được sử dụng để chỉ ra rằng hàm chuỗi đã được cung cấp một cấu trúc có chứa byte cờ, con trỏ và độ dài bộ đệm (sau đó có thể lập chỉ mục tùy ý vào bất kỳ chuỗi nào khác).

Tất nhiên, K & R đã không thực hiện bất kỳ điều gì như vậy, nhưng rất có thể là vì họ không muốn dành nhiều nỗ lực để xử lý chuỗi - một lĩnh vực mà ngay cả ngày nay nhiều ngôn ngữ có vẻ khá thiếu máu.

Theo Joel Spolsky trong bài đăng trên blog này ,

Đó là bởi vì bộ vi xử lý PDP-7, trên đó ngôn ngữ lập trình UNIX và C được phát minh, có kiểu chuỗi ASCIZ. ASCIZ có nghĩa là "ASCII có chữ Z (không) ở cuối."

Sau khi xem tất cả các câu trả lời khác ở đây, tôi tin chắc rằng ngay cả khi điều này là đúng, đó chỉ là một phần lý do khiến C có "chuỗi" kết thúc null. Bài đăng đó khá rõ ràng về việc những thứ đơn giản như chuỗi thực sự có thể khá khó khăn.

Không nhất thiết phải là Cơ sở lý luận mà là đối trọng với mã hóa chiều dài

1. Một số hình thức mã hóa chiều dài động là vượt trội so với mã hóa chiều dài tĩnh khi có liên quan đến bộ nhớ, tất cả phụ thuộc vào cách sử dụng. Chỉ cần nhìn vào UTF-8 để chứng minh. Về cơ bản, nó là một mảng ký tự mở rộng để mã hóa một ký tự đơn. Điều này sử dụng một bit cho mỗi byte mở rộng. Chấm dứt NUL sử dụng 8 bit. Tiền tố độ dài Tôi nghĩ có thể được gọi là độ dài vô hạn một cách hợp lý bằng cách sử dụng 64 bit. Tần suất bạn nhấn trường hợp các bit thừa của bạn là yếu tố quyết định. Chỉ có 1 chuỗi cực lớn? Ai quan tâm nếu bạn đang sử dụng 8 hoặc 64 bit? Nhiều chuỗi nhỏ (Ie Chuỗi các từ tiếng Anh)? Sau đó, chi phí tiền tố của bạn là một tỷ lệ lớn.

2. Chuỗi tiền tố dài cho phép tiết kiệm thời gian không phải là một điều thực sự . Cho dù dữ liệu được cung cấp của bạn được yêu cầu có độ dài được cung cấp, bạn đang tính vào thời gian biên dịch hoặc bạn thực sự được cung cấp dữ liệu động mà bạn phải mã hóa dưới dạng chuỗi. Các kích thước này được tính toán tại một số điểm trong thuật toán. Một biến riêng biệt để lưu trữ kích thước của chuỗi kết thúc null có thể được cung cấp. Mà làm cho sự so sánh về moot tiết kiệm thời gian. Một người chỉ có thêm một NUL ở cuối ... nhưng nếu mã hóa độ dài không bao gồm NUL đó thì thực sự không có sự khác biệt giữa hai. Không có thay đổi thuật toán nào cả. Chỉ cần vượt qua trước, bạn phải tự thiết kế thay vì có trình biên dịch / thời gian chạy làm việc đó cho bạn. C chủ yếu là về làm việc thủ công.

3. Tiền tố chiều dài là tùy chọn là một điểm bán hàng. Tôi không luôn cần thông tin bổ sung đó cho một thuật toán vì vậy việc được yêu cầu thực hiện nó cho mọi chuỗi làm cho thời gian tính toán trước + tính toán của tôi không bao giờ có thể giảm xuống dưới O (n). (Tức là trình tạo số ngẫu nhiên phần cứng 1-128. Tôi có thể lấy từ một "chuỗi vô hạn". Giả sử nó chỉ tạo ra các ký tự quá nhanh. Vì vậy, độ dài chuỗi của chúng tôi thay đổi mọi lúc. Nhưng cách sử dụng dữ liệu của tôi có thể không quan tâm làm thế nào Tôi có rất nhiều byte ngẫu nhiên. Nó chỉ muốn byte không được sử dụng tiếp theo ngay khi có thể nhận được nó sau một yêu cầu. Tôi có thể đợi trên thiết bị. Nhưng tôi cũng có thể có một bộ đệm các ký tự được đọc trước. một sự lãng phí không cần thiết của tính toán. Kiểm tra null hiệu quả hơn.)

4. Tiền tố dài là một bảo vệ tốt chống tràn bộ đệm? Vậy là sử dụng lành mạnh các chức năng thư viện và thực hiện. Nếu tôi chuyển dữ liệu không đúng định dạng thì sao? Bộ đệm của tôi dài 2 byte nhưng tôi nói với chức năng đó là 7! Ví dụ: Nếu get () được dự định sẽ được sử dụng trên dữ liệu đã biết, nó có thể đã có kiểm tra bộ đệm nội bộ đã kiểm tra bộ đệm đã biên dịch và malloc ()gọi và vẫn theo spec. Nếu nó được sử dụng như một đường ống để STDIN không xác định đến được vùng đệm không xác định thì rõ ràng người ta không thể biết kích thước bộ đệm có nghĩa là độ dài arg là vô nghĩa, bạn cần một thứ khác ở đây như kiểm tra chim hoàng yến. Đối với vấn đề đó, bạn không thể tiền tố dài một số luồng và đầu vào, bạn không thể. Điều đó có nghĩa là kiểm tra độ dài phải được tích hợp vào thuật toán và không phải là một phần ma thuật của hệ thống gõ. TL; DR NUL chấm dứt không bao giờ phải không an toàn, nó chỉ kết thúc theo cách đó thông qua việc sử dụng sai.

5. điểm truy cập: chấm dứt NUL gây khó chịu trên hệ nhị phân. Bạn cần phải thực hiện tiền tố độ dài ở đây hoặc chuyển đổi các byte NUL theo một cách nào đó: mã thoát, ánh xạ lại phạm vi, v.v ... tất nhiên có nghĩa là sử dụng nhiều bộ nhớ / giảm thông tin / nhiều thao tác hơn trên mỗi byte. Tiền tố dài chủ yếu chiến thắng cuộc chiến ở đây. Ưu điểm duy nhất của một phép biến đổi là không có hàm bổ sung nào phải được viết để bao trùm các chuỗi tiền tố có độ dài. Điều đó có nghĩa là trên các thói quen phụ O (n) được tối ưu hóa hơn của bạn, bạn có thể để chúng tự động hoạt động như các tương đương O (n) của chúng mà không cần thêm mã. Nhược điểm là, tất nhiên, lãng phí thời gian / bộ nhớ / nén khi được sử dụng trên các chuỗi nặng NUL.Tùy thuộc vào số lượng thư viện mà bạn kết thúc sao chép để hoạt động trên dữ liệu nhị phân, có thể có ý nghĩa khi chỉ hoạt động với các chuỗi tiền tố dài. Điều đó nói rằng người ta cũng có thể làm tương tự với các chuỗi tiền tố dài ... -1 độ dài có thể có nghĩa là chấm dứt NUL và bạn có thể sử dụng các chuỗi kết thúc NUL bên trong chấm dứt độ dài.

6. Concat: "O (n + m) vs O (m)" Tôi giả sử bạn coi m là tổng chiều dài của chuỗi sau khi nối bởi vì cả hai đều phải có số lượng hoạt động tối thiểu (bạn không thể giải quyết -trên chuỗi 1, nếu bạn phải realloc thì sao?). Và tôi cho rằng n là số lượng hoạt động thần thoại mà bạn không còn phải thực hiện vì tính toán trước. Nếu vậy, thì câu trả lời rất đơn giản: tiền điện toán. Nếubạn đang khẳng định rằng bạn sẽ luôn có đủ bộ nhớ để không cần phải phân bổ lại và đó là cơ sở của ký hiệu big-O thì câu trả lời thậm chí còn đơn giản hơn: thực hiện tìm kiếm nhị phân trên bộ nhớ được phân bổ cho cuối chuỗi 1, rõ ràng có rất nhiều swatch các số 0 vô hạn sau chuỗi 1 để chúng ta không phải lo lắng về realloc. Ở đó, dễ dàng có n để đăng nhập (n) và tôi hầu như không thử. Mà nếu bạn nhớ lại log (n) về cơ bản chỉ lớn bằng 64 trên một máy tính thực, về cơ bản giống như nói O (64 + m), về cơ bản là O (m). (Và vâng, logic đó đã được sử dụng trong phân tích thời gian thực của các cấu trúc dữ liệu thực tế đang sử dụng ngày nay. Nó không nhảm nhí trên đỉnh đầu của tôi.)

7. Concat () / Len () _{lần nữa} : Ghi nhớ kết quả. Dễ dàng. Biến tất cả các tính toán thành tiền tính toán nếu có thể / cần thiết. Đây là một quyết định thuật toán. Đó không phải là một ràng buộc bắt buộc của ngôn ngữ.

8. Chuỗi hậu tố đi qua dễ dàng hơn / có thể với chấm dứt NUL. Tùy thuộc vào cách triển khai tiền tố dài, nó có thể bị phá hủy trên chuỗi gốc và đôi khi thậm chí không thể thực hiện được. Yêu cầu một bản sao và vượt qua O (n) thay vì O (1).

9. Đối số chuyển qua / bỏ tham chiếu ít hơn đối với tiền tố NUL kết thúc so với tiền tố dài. Rõ ràng bởi vì bạn đang truyền ít thông tin hơn. Nếu bạn không cần chiều dài, thì điều này sẽ tiết kiệm rất nhiều dấu chân và cho phép tối ưu hóa.

10. Bạn có thể gian lận. Nó thực sự chỉ là một con trỏ. Ai nói bạn phải đọc nó như một chuỗi? Điều gì nếu bạn muốn đọc nó như là một nhân vật duy nhất hoặc nổi? Điều gì nếu bạn muốn làm ngược lại và đọc một float như một chuỗi? Nếu bạn cẩn thận, bạn có thể làm điều này với chấm dứt NUL. Bạn không thể làm điều này với tiền tố độ dài, đó là loại dữ liệu khác biệt với con trỏ thông thường. Bạn rất có thể phải xây dựng một chuỗi byte theo byte và có được độ dài. Tất nhiên nếu bạn muốn một cái gì đó giống như toàn bộ float (có thể có NUL bên trong nó) thì bạn phải đọc từng byte một, nhưng các chi tiết còn lại để bạn quyết định.

TL; DR Bạn đang sử dụng dữ liệu nhị phân? Nếu không, thì chấm dứt NUL cho phép tự do thuật toán hơn. Nếu có, thì số lượng mã so với tốc độ / bộ nhớ / nén là mối quan tâm chính của bạn. Một sự pha trộn của hai cách tiếp cận hoặc ghi nhớ có thể là tốt nhất.

Tôi không mua câu trả lời "C không có chuỗi". Đúng, C không hỗ trợ các loại mức cao hơn tích hợp nhưng bạn vẫn có thể biểu diễn các cấu trúc dữ liệu trong C và đó là chuỗi. Thực tế một chuỗi chỉ là một con trỏ trong C không có nghĩa là N byte đầu tiên không thể có ý nghĩa đặc biệt như độ dài.

Các nhà phát triển Windows / COM sẽ rất quen thuộc với BSTRkiểu giống hệt như thế này - một chuỗi C có tiền tố dài, trong đó dữ liệu ký tự thực tế bắt đầu không ở byte 0.

Vì vậy, dường như quyết định sử dụng chấm dứt null chỉ đơn giản là những gì mọi người ưa thích, không phải là một sự cần thiết của ngôn ngữ.

gcc chấp nhận các mã dưới đây:

char s [4] = "abcd";

và nó ổn nếu chúng ta coi là một mảng ký tự nhưng không phải là chuỗi. Đó là, chúng ta có thể truy cập nó với s [0], s [1], s [2] và s [3] hoặc thậm chí với memcpy (mệnh, s, 4). Nhưng chúng ta sẽ nhận được các ký tự lộn xộn khi chúng ta cố gắng đặt (s) hoặc tệ hơn với strcpy (mệnh, s).