trỏ tới mảng C++

Question

Mã sau đây đang làm gì?

int g[] = {9,8}; 
int (*j) = g; 

Từ sự hiểu biết của tôi, việc tạo con trỏ tới một mảng gồm 2 int. Nhưng sau đó tại sao công việc này:

int x = j[0]; 

và điều này không làm việc:

int x = (*j)[0]; 

Answer 1

Dấu ngoặc đơn thừa trong ví dụ của bạn. Con trỏ không quan tâm liệu có là một mảng có liên quan - nó chỉ biết rằng trỏ của mình cho một int

int g[] = {9,8}; 
    int (*j) = g; 

cũng có thể được viết lại như

int g[] = {9,8}; 
    int *j = g; 

mà cũng có thể được viết lại như

int g[] = {9,8}; 
    int *j = &g[0]; 

một con trỏ tới một mảng sẽ trông giống như

int g[] = {9,8}; 
    int (*j)[2] = &g; 

    //Dereference 'j' and access array element zero 
    int n = (*j)[0]; 

Có một đọc tốt trên tờ khai con trỏ (và làm thế nào để grok họ) tại liên kết này ở đây: http://www.codeproject.com/Articles/7042/How-to-interpret-complex-C-C-declarations

Answer 2

j[0]; dereferences một con trỏ đến int, vì vậy loại của nó là int.

(*j)[0] không có loại. *j chỉ định con trỏ đến một số int, do đó, nó trả về một số int và (*j)[0] các nỗ lực để coi trọng một số int. Nó giống như cố gắng int x = 8; x[0];.

Answer 3

int g[] = {9,8}; 

này tuyên bố một đối tượng kiểu int [2], và khởi yếu tố của nó để {9 , 8}

int (*j) = g; 

này tuyên bố một đối tượng kiểu int *, và khởi tạo nó với một con trỏ đến phần tử đầu tiên của g.

Thực tế là khai báo thứ hai khởi tạo j với một cái gì đó khác với g là khá lạ. C và C++ chỉ có những quy tắc kỳ lạ về mảng, và đây là một trong số chúng. Ở đây, biểu thức g được chuyển đổi hoàn toàn từ một giá trị tham chiếu đến đối tượng g thành một rvalue thuộc loại int* trỏ vào phần tử đầu tiên của g.

Chuyển đổi này xảy ra ở một số nơi. Trong thực tế nó xảy ra khi bạn làm g[0]. Toán tử chỉ mục mảng không thực sự làm việc trên các mảng, chỉ trên con trỏ. Vì vậy, các tuyên bố int x = j[0]; hoạt động vì g[0] xảy ra để làm điều đó cùng một chuyển đổi tiềm ẩn đã được thực hiện khi j được khởi tạo.

Một con trỏ đến một mảng được khai báo như thế này

int (*k)[2]; 

và bạn hoàn toàn đúng về cách thức này sẽ được sử dụng

int x = (*k)[0]; 

(lưu ý cách "declaration follows use", tức là cú pháp cho tuyên bố biến của loại bắt chước cú pháp cho sử dụng biến số đó.)

Tuy nhiên, người ta thường không sử dụng một con trỏ đến một mảng. Toàn bộ mục đích của các quy tắc đặc biệt xung quanh mảng là để bạn có thể sử dụng một con trỏ tới một phần tử mảng như thể nó là một mảng. Vì vậy, thành ngữ C thường không quan tâm đến mảng và con trỏ không giống nhau, và các quy tắc ngăn bạn làm nhiều thứ hữu ích trực tiếp với mảng. (Ví dụ như bạn không thể sao chép một mảng như: int g[2] = {1,2}; int h[2]; h = g;)

---

Ví dụ:

void foo(int c[10]); // looks like we're taking an array by value. 
// Wrong, the parameter type is 'adjusted' to be int* 

int bar[3] = {1,2}; 
foo(bar); // compile error due to wrong types (int[3] vs. int[10])? 
// No, compiles fine but you'll probably get undefined behavior at runtime 

// if you want type checking, you can pass arrays by reference (or just use std::array): 
void foo2(int (&c)[10]); // paramater type isn't 'adjusted' 
foo2(bar); // compiler error, cannot convert int[3] to int (&)[10] 

int baz()[10]; // returning an array by value? 
// No, return types are prohibited from being an array. 

int g[2] = {1,2}; 
int h[2] = g; // initializing the array? No, initializing an array requires {} syntax 
h = g; // copying an array? No, assigning to arrays is prohibited 

---

Vì mảng rất không phù hợp với các loại khác trong C và C++, bạn nên chỉ cần tránh chúng. C++ có std::array phù hợp hơn và bạn nên sử dụng nó khi bạn cần các mảng có kích thước tĩnh. Nếu bạn cần mảng có kích thước động, tùy chọn đầu tiên của bạn là std :: vector.