Các chức năng của thư viện C có luôn mong đợi độ dài của chuỗi không?

Tôi hiện đang làm việc trên một thư viện được viết bằng C. Nhiều chức năng của thư viện này mong đợi một chuỗi như char*hoặc const char*trong các đối số của chúng. Tôi đã bắt đầu với các hàm đó luôn mong đợi độ dài của chuỗi size_tvì không yêu cầu chấm dứt null. Tuy nhiên, khi viết bài kiểm tra, điều này dẫn đến việc sử dụng thường xuyên strlen(), như vậy:

const char* string = "Ugh, strlen is tedious";
libFunction(string, strlen(string));

Việc tin tưởng người dùng vượt qua các chuỗi kết thúc đúng sẽ dẫn đến mã kém an toàn hơn, nhưng ngắn gọn hơn và (theo ý kiến ​​của tôi):

libFunction("I hope there's a null-terminator there!");

Vì vậy, những gì thực hành hợp lý ở đây? Làm cho API phức tạp hơn để sử dụng, nhưng buộc người dùng phải nghĩ đến đầu vào của họ hoặc ghi lại yêu cầu cho chuỗi kết thúc null và tin tưởng người gọi?

Chắc chắn nhất và hoàn toàn mang theo chiều dài xung quanh . Thư viện C tiêu chuẩn bị phá vỡ một cách khét tiếng theo cách này, điều này đã không gây ra kết thúc đau đớn trong việc xử lý tràn bộ đệm. Cách tiếp cận này là trọng tâm của rất nhiều thù hận và nỗi thống khổ mà các trình biên dịch hiện đại sẽ thực sự cảnh báo, than vãn và phàn nàn khi sử dụng các chức năng thư viện tiêu chuẩn loại này.

Thật tệ, đến nỗi nếu bạn từng gặp câu hỏi này trong một cuộc phỏng vấn - và người phỏng vấn kỹ thuật của bạn có vẻ như anh ta có một vài năm kinh nghiệm - nhiệt tâm thuần túy có thể hạ cánh công việc - bạn thực sự có thể tiến xa hơn nếu bạn có thể trích dẫn tiền lệ của việc bắn ai đó thực hiện API tìm kiếm bộ kết thúc chuỗi C.

Bỏ cảm xúc của nó sang một bên, có rất nhiều điều có thể sai với NULL ở cuối chuỗi của bạn, trong cả việc đọc và thao tác với nó - cộng với việc nó thực sự vi phạm trực tiếp các khái niệm thiết kế hiện đại như phòng thủ chuyên sâu (không nhất thiết phải áp dụng cho bảo mật, nhưng cho thiết kế API). Ví dụ về API C mang theo chiều dài rất nhiều - ví dụ. API Windows.

Trên thực tế, vấn đề này đã được giải quyết vào khoảng những năm 90, sự đồng thuận mới nổi ngày nay là bạn thậm chí không nên chạm vào chuỗi của mình .

Chỉnh sửa sau : đây là một cuộc tranh luận trực tiếp, vì vậy tôi sẽ thêm rằng tin tưởng mọi người bên dưới và bên trên bạn là tốt và sử dụng các chức năng str * của thư viện là OK, cho đến khi bạn thấy những thứ cổ điển như output = malloc(strlen(input)); strcpy(output, input);hoặc while(*src) { *dest=transform(*src); dest++; src++; }. Tôi gần như có thể nghe Lacrimosa của Mozart trong nền.

Trong C, thành ngữ là các chuỗi ký tự bị chấm dứt NUL, do đó, việc tuân thủ thông lệ thông thường - thực sự không chắc là người dùng thư viện sẽ có các chuỗi không kết thúc NUL (vì chúng cần thêm công việc để in sử dụng printf và sử dụng trong bối cảnh khác). Sử dụng bất kỳ loại chuỗi nào khác là không tự nhiên và có lẽ tương đối hiếm.

Ngoài ra, trong các trường hợp, thử nghiệm của bạn có vẻ hơi kỳ lạ đối với tôi, vì để hoạt động chính xác (sử dụng strlen), bạn đang giả sử một chuỗi kết thúc NUL ở vị trí đầu tiên. Bạn nên kiểm tra trường hợp các chuỗi không kết thúc NUL nếu bạn dự định thư viện của bạn sẽ làm việc với chúng.

Đối số "an toàn" của bạn không thực sự giữ. Nếu bạn không tin tưởng người dùng trao cho bạn một chuỗi kết thúc không có giá trị khi đó là những gì bạn đã ghi lại (và "chuẩn mực" cho đồng bằng C), bạn không thể thực sự tin tưởng vào độ dài mà họ cung cấp cho bạn (mà họ sẽ có thể nhận được bằng cách sử dụng strlengiống như bạn đang làm nếu họ không có nó và sẽ thất bại nếu "chuỗi" không phải là một chuỗi ở vị trí đầu tiên).

Có nhiều lý do hợp lệ để yêu cầu độ dài mặc dù: nếu bạn muốn các chức năng của mình hoạt động trên các chuỗi con, có thể dễ dàng hơn (và hiệu quả) để vượt qua một độ dài so với việc người dùng thực hiện một số phép thuật sao chép qua lại để có được byte null ở đúng nơi (và có nguy cơ xảy ra lỗi trên đường đi).
Có thể xử lý các mã hóa trong đó các byte null không phải là kết thúc hoặc có thể xử lý các chuỗi có null null (có mục đích) có thể hữu ích trong một số trường hợp (phụ thuộc vào chức năng của bạn làm gì).
Khả năng xử lý dữ liệu không kết thúc (mảng có độ dài cố định) cũng rất tiện lợi.
Tóm lại: phụ thuộc vào những gì bạn đang làm trong thư viện của bạn và loại dữ liệu bạn mong muốn người dùng của bạn sẽ xử lý.

Cũng có thể có một khía cạnh hiệu suất cho việc này. Nếu chức năng của bạn cần biết trước độ dài của chuỗi và bạn mong muốn người dùng của mình ít nhất thường biết thông tin đó, việc họ vượt qua nó (thay vì bạn tính toán nó) có thể cạo một vài chu kỳ.

Nhưng nếu thư viện của bạn mong đợi các chuỗi văn bản ASCII đơn giản thông thường và bạn không gặp phải các hạn chế về hiệu suất và hiểu rất rõ về cách người dùng của bạn sẽ tương tác với thư viện của bạn, việc thêm một tham số độ dài nghe có vẻ không phải là một ý tưởng hay. Nếu chuỗi không được kết thúc đúng cách, rất có thể tham số độ dài sẽ chỉ là không có thật. Tôi không nghĩ bạn sẽ đạt được nhiều với nó.

Số chuỗi luôn được kết thúc bằng null theo định nghĩa, độ dài chuỗi là dự phòng.

Dữ liệu ký tự không kết thúc không bao giờ được gọi là "chuỗi". Việc xử lý nó (và ném độ dài xung quanh) thường phải được gói gọn trong thư viện và không phải là một phần của API. Yêu cầu độ dài làm tham số chỉ để tránh các lệnh gọi strlen () có khả năng Tối ưu hóa sớm.

Tin tưởng người gọi hàm API không an toàn ; hành vi không xác định là hoàn toàn ok nếu điều kiện tiên quyết không được đáp ứng.

Tất nhiên, API được thiết kế tốt không nên chứa những cạm bẫy và giúp dễ dàng sử dụng chính xác. Và điều này chỉ có nghĩa là nó phải đơn giản và dễ hiểu nhất có thể, tránh sự dư thừa và tuân theo các quy ước của ngôn ngữ.

Bạn nên luôn luôn giữ chiều dài của bạn xung quanh. Đối với một, người dùng của bạn có thể muốn chứa NULL trong đó. Và thứ hai, đừng quên đó strlenlà O (N) và yêu cầu chạm vào toàn bộ bộ đệm tạm biệt chuỗi. Và thứ ba, nó giúp việc vượt qua các tập hợp con dễ dàng hơn - ví dụ, chúng có thể cho ít hơn chiều dài thực tế.

Bạn nên phân biệt giữa việc truyền xung quanh một chuỗi và chuyển qua một bộ đệm .

Trong C, các chuỗi được kết thúc NUL theo truyền thống. Nó là hoàn toàn hợp lý để mong đợi điều này. Do đó, thường không cần phải vượt qua độ dài của chuỗi; nó có thể được tính toán strlennếu cần thiết.

Khi đi qua một bộ đệm , đặc biệt là một bộ đệm được ghi vào, thì bạn hoàn toàn nên chuyển dọc theo kích thước bộ đệm. Đối với bộ đệm đích, điều này cho phép callee đảm bảo rằng nó không tràn bộ đệm. Đối với bộ đệm đầu vào, nó cho phép callee tránh đọc quá cuối, đặc biệt nếu bộ đệm đầu vào chứa dữ liệu tùy ý có nguồn gốc từ một nguồn không đáng tin cậy.

Có lẽ có một số nhầm lẫn bởi vì cả chuỗi và bộ đệm đều có thể char*và bởi vì rất nhiều hàm chuỗi tạo ra chuỗi mới bằng cách ghi vào bộ đệm đích. Một số người sau đó kết luận rằng các hàm chuỗi nên có độ dài chuỗi. Tuy nhiên, đây là một kết luận không chính xác. Việc thực hành bao gồm một kích thước với một bộ đệm (cho dù bộ đệm đó được sử dụng cho chuỗi, mảng số nguyên, cấu trúc, bất cứ thứ gì) là một câu thần chú hữu ích và tổng quát hơn.

(Trong trường hợp đọc một chuỗi từ một nguồn không tin cậy (ví dụ: ổ cắm mạng), điều quan trọng là cung cấp độ dài vì đầu vào có thể không bị chấm dứt NUL. Tuy nhiên , bạn không nên coi đầu vào là một chuỗi. nên coi nó như một bộ đệm dữ liệu tùy ý có thể chứa một chuỗi (nhưng bạn không biết cho đến khi bạn thực sự xác nhận nó), vì vậy điều này vẫn tuân theo nguyên tắc là bộ đệm nên có kích thước liên quan và chuỗi đó không cần chúng.)

Nếu các chức năng chủ yếu được sử dụng với chuỗi ký tự, thì nỗi đau của việc xử lý độ dài rõ ràng có thể được giảm thiểu bằng cách xác định một số macro. Ví dụ: được cung cấp một hàm API:

void use_string(char *string, int length);

người ta có thể định nghĩa một macro:

#define use_strlit(x) use_string(x, sizeof ("" x "")-1)

và sau đó gọi nó như thể hiện trong:

void test(void)
{
  use_strlit("Hello");
}

Mặc dù có thể đưa ra những thứ "sáng tạo" để vượt qua macro sẽ biên dịch nhưng thực tế sẽ không hoạt động, việc sử dụng ""một trong hai bên của chuỗi trong đánh giá "sizeof" sẽ bắt gặp những nỗ lực vô tình để sử dụng ký tự các con trỏ khác với các chuỗi ký tự phân tách [trong trường hợp không có các ký tự chuỗi "", một nỗ lực để vượt qua một con trỏ ký tự sẽ đưa ra độ dài là kích thước của một con trỏ, trừ đi một chiều.

Một cách tiếp cận khác trong C99 sẽ là xác định loại cấu trúc "con trỏ và chiều dài" và xác định một macro chuyển đổi một chuỗi ký tự thành một nghĩa đen của loại cấu trúc đó. Ví dụ:

struct lstring { char const *ptr; int length; };
#define as_lstring(x) \
  (( struct lstring const) {x, sizeof("" x "")-1})

Lưu ý rằng nếu sử dụng một cách tiếp cận như vậy, người ta nên chuyển các cấu trúc như vậy theo giá trị thay vì chuyển qua địa chỉ của chúng. Nếu không thì đại loại như:

struct lstring *p;
if (foo)
{
  p = &as_lstring("Hello");
}
else
{
  p = &as_lstring("Goodbye!");
}
use_lstring(p);

có thể thất bại vì thời gian tồn tại của chữ ghép sẽ kết thúc ở phần cuối của câu lệnh kèm theo.