Mảng để phân rã con trỏ là gì?

Mảng để phân rã con trỏ là gì? Có bất kỳ liên quan đến con trỏ mảng?

Người ta nói rằng mảng "phân rã" thành con trỏ. Một mảng C ++ được khai báo là int numbers [5]không thể được trỏ lại, tức là bạn không thể nói numbers = 0x5a5aff23. Quan trọng hơn, thuật ngữ phân rã có nghĩa là mất loại và kích thước; numbersphân rã int*bằng cách mất thông tin kích thước (số 5) và loại không int [5]còn nữa. Nhìn vào đây để biết trường hợp sâu răng không xảy ra .

Nếu bạn truyền một mảng theo giá trị, những gì bạn thực sự đang làm là sao chép một con trỏ - một con trỏ tới phần tử đầu tiên của mảng được sao chép vào tham số (kiểu của nó cũng phải là con trỏ kiểu của phần tử mảng). Điều này hoạt động do tính chất phân rã của mảng; một khi đã phân rã, sizeofkhông còn cho kích thước của mảng hoàn chỉnh, vì về cơ bản nó trở thành một con trỏ. Đây là lý do tại sao nó được ưu tiên (trong số các lý do khác) để vượt qua bằng tham chiếu hoặc con trỏ.

Ba cách để vượt qua trong mảng ¹ :

void by_value(const T* array)   // const T array[] means the same
void by_pointer(const T (*array)[U])
void by_reference(const T (&array)[U])

Hai cái cuối cùng sẽ cung cấp sizeofthông tin chính xác, trong khi cái đầu tiên sẽ không vì đối số mảng đã phân rã để được gán cho tham số.

^{1 Hằng số U nên được biết tại thời gian biên dịch.}

Mảng về cơ bản giống như con trỏ trong C / C ++, nhưng không hoàn toàn. Khi bạn chuyển đổi một mảng:

const int a[] = { 2, 3, 5, 7, 11 };

vào một con trỏ (hoạt động mà không cần truyền, và do đó có thể xảy ra bất ngờ trong một số trường hợp):

const int* p = a;

bạn mất khả năng của sizeoftoán tử để đếm các phần tử trong mảng:

assert( sizeof(p) != sizeof(a) );  // sizes are not equal

Khả năng bị mất này được gọi là "phân rã".

Để biết thêm chi tiết, hãy xem bài viết này về phân rã mảng .

Đây là những gì tiêu chuẩn nói (C99 6.3.2.1/3 - Các toán hạng khác - Giá trị, mảng và chỉ định hàm):

Ngoại trừ khi đó là toán hạng của toán tử sizeof hoặc toán tử unary & toán tử hoặc là một chuỗi ký tự được sử dụng để khởi tạo một mảng, một biểu thức có kiểu '' mảng kiểu '' được chuyển đổi thành một biểu thức có con trỏ kiểu '' thành gõ '' trỏ đến phần tử ban đầu của đối tượng mảng và không phải là giá trị.

Điều này có nghĩa là khá nhiều bất cứ lúc nào tên mảng được sử dụng trong một biểu thức, nó được tự động chuyển đổi thành một con trỏ đến mục thứ 1 trong mảng.

Lưu ý rằng tên hàm hoạt động theo cách tương tự, nhưng con trỏ hàm được sử dụng ít hơn nhiều và theo cách chuyên biệt hơn nhiều, nó không gây ra sự nhầm lẫn nhiều như việc chuyển đổi tự động tên mảng thành con trỏ.

Tiêu chuẩn C ++ (4.2 Chuyển đổi mảng sang con trỏ) nới lỏng yêu cầu chuyển đổi thành (nhấn mạnh của tôi):

Có thể chuyển đổi một giá trị hoặc giá trị của mảng kiểu dữ liệu của NT NT hoặc mảng có giới hạn không xác định của TÊ có thể được chuyển đổi thành một giá trị của con trỏ kiểu loại thành T.

Vì vậy, việc chuyển đổi không có xảy ra như nó khá nhiều luôn luôn làm trong C (điều này cho phép các chức năng quá tải hoặc mẫu nào khớp vào loại mảng).

Đây cũng là lý do tại sao trong C, bạn nên tránh sử dụng các tham số mảng trong các nguyên mẫu / định nghĩa hàm (theo ý kiến ​​của tôi - tôi không chắc có bất kỳ thỏa thuận chung nào không). Chúng gây nhầm lẫn và dù sao cũng là hư cấu - sử dụng các tham số con trỏ và sự nhầm lẫn có thể không biến mất hoàn toàn, nhưng ít nhất khai báo tham số không nói dối.

"Decay" dùng để chuyển đổi ngầm định một biểu thức từ kiểu mảng sang kiểu con trỏ. Trong hầu hết các bối cảnh, khi trình biên dịch nhìn thấy một biểu thức mảng, nó chuyển đổi loại biểu thức từ "mảng phần tử N của T" thành "con trỏ thành T" và đặt giá trị của biểu thức thành địa chỉ của phần tử đầu tiên của mảng . Các ngoại lệ cho quy tắc này là khi một mảng là toán hạng của toán tử sizeofhoặc &toán tử hoặc mảng là một chuỗi ký tự được sử dụng làm bộ khởi tạo trong khai báo.

Giả sử mã sau:

char a[80];
strcpy(a, "This is a test");

Biểu thức acó kiểu "mảng 80 phần tử của char" và biểu thức "Đây là một bài kiểm tra" thuộc loại "mảng 16 phần tử của char" (trong C; trong chuỗi C ++ là các mảng của const char). Tuy nhiên, trong lệnh gọi strcpy(), không biểu thức nào là toán hạng của sizeofhoặc &, do đó các kiểu của chúng được chuyển đổi hoàn toàn thành "con trỏ thành char" và các giá trị của chúng được đặt thành địa chỉ của phần tử đầu tiên trong mỗi. Những gì strcpy()nhận được không phải là mảng, mà là con trỏ, như đã thấy trong nguyên mẫu của nó:

char *strcpy(char *dest, const char *src);

Đây không phải là điều tương tự như một con trỏ mảng. Ví dụ:

char a[80];
char *ptr_to_first_element = a;
char (*ptr_to_array)[80] = &a;

Cả hai ptr_to_first_elementvà ptr_to_arraycó cùng giá trị ; địa chỉ cơ sở của a. Tuy nhiên, chúng là các loại khác nhau và được xử lý khác nhau, như được hiển thị dưới đây:

a[i] == ptr_to_first_element[i] == (*ptr_to_array)[i] != *ptr_to_array[i] != ptr_to_array[i]

Hãy nhớ rằng biểu thức a[i]được hiểu là *(a+i)(chỉ hoạt động nếu kiểu mảng được chuyển đổi thành loại con trỏ), vì vậy cả hai a[i]và ptr_to_first_element[i]hoạt động như nhau. Biểu thức (*ptr_to_array)[i]được hiểu là *(*a+i). Các biểu thức *ptr_to_array[i]và ptr_to_array[i]có thể dẫn đến cảnh báo trình biên dịch hoặc lỗi tùy thuộc vào ngữ cảnh; họ chắc chắn sẽ làm điều sai trái nếu bạn mong đợi họ đánh giá a[i].

sizeof a == sizeof *ptr_to_array == 80

Một lần nữa, khi một mảng là toán hạng của sizeofnó, nó không được chuyển đổi thành kiểu con trỏ.

sizeof *ptr_to_first_element == sizeof (char) == 1
sizeof ptr_to_first_element == sizeof (char *) == whatever the pointer size
                                                  is on your platform

ptr_to_first_element là một con trỏ đơn giản để char.

Mảng, trong C, không có giá trị.

Bất cứ nơi nào giá trị của một đối tượng được mong đợi nhưng đối tượng là một mảng, địa chỉ của phần tử đầu tiên của nó được sử dụng thay thế, với kiểu pointer to (type of array elements).

Trong một hàm, tất cả các tham số được truyền theo giá trị (mảng không phải là ngoại lệ). Khi bạn truyền một mảng trong hàm, nó "phân rã thành một con trỏ" (sic); khi bạn so sánh một mảng với một thứ khác, một lần nữa nó "phân rã thành một con trỏ" (sic); ...

void foo(int arr[]);

Hàm foo mong đợi giá trị của một mảng. Nhưng, trong C, mảng không có giá trị! Vì vậy, foothay vì địa chỉ của phần tử đầu tiên của mảng.

int arr[5];
int *ip = &(arr[1]);
if (arr == ip) { /* something; */ }

Trong so sánh ở trên, arrkhông có giá trị, vì vậy nó trở thành một con trỏ. Nó trở thành một con trỏ tới int. Con trỏ đó có thể được so sánh với biến ip.

Trong cú pháp lập chỉ mục mảng mà bạn thường thấy, một lần nữa, mảng bị 'phân rã thành một con trỏ'

arr[42];
/* same as *(arr + 42); */
/* same as *(&(arr[0]) + 42); */

Lần duy nhất một mảng không phân rã thành một con trỏ là khi nó là toán hạng của toán tử sizeof hoặc toán tử & (toán tử 'địa chỉ của toán tử) hoặc như một chuỗi ký tự được sử dụng để khởi tạo một mảng ký tự.

Đó là khi mảng thối và đang được chỉ vào ;-)

Trên thực tế, chỉ là nếu bạn muốn truyền một mảng ở đâu đó, nhưng con trỏ được truyền thay thế (bởi vì ai sẽ truyền toàn bộ mảng cho bạn), mọi người nói rằng mảng kém đó đã phân rã thành con trỏ.

Phân rã mảng có nghĩa là, khi một mảng được truyền dưới dạng tham số cho hàm, nó được xử lý giống hệt ("phân rã thành") một con trỏ.

void do_something(int *array) {
  // We don't know how big array is here, because it's decayed to a pointer.
  printf("%i\n", sizeof(array));  // always prints 4 on a 32-bit machine
}

int main (int argc, char **argv) {
    int a[10];
    int b[20];
    int *c;
    printf("%zu\n", sizeof(a)); //prints 40 on a 32-bit machine
    printf("%zu\n", sizeof(b)); //prints 80 on a 32-bit machine
    printf("%zu\n", sizeof(c)); //prints 4 on a 32-bit machine
    do_something(a);
    do_something(b);
    do_something(c);
}

Có hai biến chứng hoặc ngoại lệ ở trên.

Đầu tiên, khi xử lý các mảng đa chiều trong C và C ++, chỉ có chiều thứ nhất bị mất. Điều này là do các mảng được đặt liền kề trong bộ nhớ, do đó trình biên dịch phải biết tất cả ngoại trừ kích thước đầu tiên để có thể tính toán độ lệch vào khối bộ nhớ đó.

void do_something(int array[][10])
{
    // We don't know how big the first dimension is.
}

int main(int argc, char *argv[]) {
    int a[5][10];
    int b[20][10];
    do_something(a);
    do_something(b);
    return 0;
}

Thứ hai, trong C ++, bạn có thể sử dụng các mẫu để suy ra kích thước của mảng. Microsoft sử dụng điều này cho các phiên bản C ++ của các hàm CRT bảo mật như strcpy_s và bạn có thể sử dụng một mẹo tương tự để lấy số lượng phần tử trong một mảng một cách đáng tin cậy .

tl; dr: Khi bạn sử dụng một mảng bạn đã xác định, bạn thực sự sẽ sử dụng một con trỏ đến phần tử đầu tiên của nó.

Như vậy:

• Khi bạn viết arr[idx]bạn thực sự chỉ cần nói *(arr + idx).
• các hàm không bao giờ thực sự lấy mảng làm tham số, chỉ con trỏ, ngay cả khi bạn chỉ định tham số mảng.

Sắp xếp các ngoại lệ cho quy tắc này:

• Bạn có thể chuyển các mảng có độ dài cố định cho các hàm trong a struct.
• sizeof() đưa ra kích thước được lấy bởi mảng, không phải kích thước của một con trỏ.

Tôi có thể rất táo bạo khi nghĩ rằng có bốn (4) cách để truyền một mảng làm đối số hàm. Ngoài ra đây là mã ngắn nhưng làm việc cho sự nhìn chăm chú của bạn.

#include <iostream>
#include <string>
#include <vector>
#include <cassert>

using namespace std;

// test data
// notice native array init with no copy aka "="
// not possible in C
 const char* specimen[]{ __TIME__, __DATE__, __TIMESTAMP__ };

// ONE
// simple, dangerous and useless
template<typename T>
void as_pointer(const T* array) { 
    // a pointer
    assert(array != nullptr); 
} ;

// TWO
// for above const T array[] means the same
// but and also , minimum array size indication might be given too
// this also does not stop the array decay into T *
// thus size information is lost
template<typename T>
void by_value_no_size(const T array[0xFF]) { 
    // decayed to a pointer
    assert( array != nullptr ); 
}

// THREE
// size information is preserved
// but pointer is asked for
template<typename T, size_t N>
void pointer_to_array(const T (*array)[N])
{
   // dealing with native pointer 
    assert( array != nullptr ); 
}

// FOUR
// no C equivalent
// array by reference
// size is preserved
template<typename T, size_t N>
void reference_to_array(const T (&array)[N])
{
    // array is not a pointer here
    // it is (almost) a container
    // most of the std:: lib algorithms 
    // do work on array reference, for example
    // range for requires std::begin() and std::end()
    // on the type passed as range to iterate over
    for (auto && elem : array )
    {
        cout << endl << elem ;
    }
}

int main()
{
     // ONE
     as_pointer(specimen);
     // TWO
     by_value_no_size(specimen);
     // THREE
     pointer_to_array(&specimen);
     // FOUR
     reference_to_array( specimen ) ;
}

Tôi cũng có thể nghĩ rằng điều này cho thấy sự vượt trội của C ++ so với C. Ít nhất là trong tham chiếu (ý định chơi chữ) của việc truyền một mảng bằng cách tham chiếu.

Tất nhiên có những dự án cực kỳ nghiêm ngặt không có phân bổ heap, không có ngoại lệ và không có std :: lib. Xử lý mảng gốc C ++ là tính năng ngôn ngữ quan trọng, người ta có thể nói.