PointersIn earlier chapters, variab

Pointers
In earlier chapters, variables have been explained as locations in the computer's memory which can be accessed by their identifier (their name). This way, the program does not need to care about the physical address of the data in memory; it simply uses the identifier whenever it needs to refer to the variable.

For a C++ program, the memory of a computer is like a succession of memory cells, each one byte in size, and each with a unique address. These single-byte memory cells are ordered in a way that allows data representations larger than one byte to occupy memory cells that have consecutive addresses.

This way, each cell can be easily located in the memory by means of its unique address. For example, the memory cell with the address 1776 always follows immediately after the cell with address 1775 and precedes the one with 1777, and is exactly one thousand cells after 776 and exactly one thousand cells before 2776.

When a variable is declared, the memory needed to store its value is assigned a specific location in memory (its memory address). Generally, C++ programs do not actively decide the exact memory addresses where its variables are stored. Fortunately, that task is left to the environment where the program is run - generally, an operating system that decides the particular memory locations on runtime. However, it may be useful for a program to be able to obtain the address of a variable during runtime in order to access data cells that are at a certain position relative to it.

Address-of operator (&)
The address of a variable can be obtained by preceding the name of a variable with an ampersand sign (&), known as address-of operator. For example:


foo = &myvar;


This would assign the address of variable myvar to foo; by preceding the name of the variable myvar with the address-of operator (&), we are no longer assigning the content of the variable itself to foo, but its address.

The actual address of a variable in memory cannot be known before runtime, but let's assume, in order to help clarify some concepts, that myvar is placed during runtime in the memory address 1776.

In this case, consider the following code fragment:

1
2
3
myvar = 25;
foo = &myvar;
bar = myvar;


The values contained in each variable after the execution of this are shown in the following diagram:



First, we have assigned the value 25 to myvar (a variable whose address in memory we assumed to be 1776).

The second statement assigns foo the address of myvar, which we have assumed to be 1776.

Finally, the third statement, assigns the value contained in myvar to bar. This is a standard assignment operation, as already done many times in earlier chapters.

The main difference between the second and third statements is the appearance of the address-of operator (&).

The variable that stores the address of another variable (like foo in the previous example) is what in C++ is called a pointer. Pointers are a very powerful feature of the language that has many uses in lower level programming. A bit later, we will see how to declare and use pointers.

Dereference operator (*)
As just seen, a variable which stores the address of another variable is called a pointer. Pointers are said to "point to" the variable whose address they store.

An interesting property of pointers is that they can be used to access the variable they point to directly. This is done by preceding the pointer name with the dereference operator (*). The operator itself can be read as "value pointed to by".

Therefore, following with the values of the previous example, the following statement:


baz = *foo;


This could be read as: "baz equal to value pointed to by foo", and the statement would actually assign the value 25 to baz, since foo is 1776, and the value pointed to by 1776 (following the example above) would be 25.


It is important to clearly differentiate that foo refers to the value 1776, while *foo (with an asterisk * preceding the identifier) refers to the value stored at address 1776, which in this case is 25. Notice the difference of including or not including the dereference operator (I have added an explanatory comment of how each of these two expressions could be read):

1
2
baz = foo; // baz equal to foo (1776)
baz = *foo; // baz equal to value pointed to by foo (25)


The reference and dereference operators are thus complementary:
& is the address-of operator, and can be read simply as "address of"
* is the dereference operator, and can be read as "value pointed to by"

Thus, they have sort of opposite meanings: An address obtained with & can be dereferenced with *.

Earlier, we performed the following two assignment operations:

1
2
myvar = 25;
foo = &myvar;


Right after these two statements, all of the following expressions would give true as result:

1
2
3
4
myvar == 25
&myvar == 1776
foo == 1776
*foo == 25


The first expression is quite clear, considering that the assignment operation performed on myvar was myvar=25. The second one uses the address-of operator (&), which returns the address of myvar, which we assumed it to have a value of 1776. The third one is somewhat obvious, since the second expression was true and the assignment operation performed on foo was foo=&myvar. The fourth expression uses the dereference operator (*) that can be read as "value pointed to by", and the value pointed to by foo is indeed 25.

So, after all that, you may also infer that for as long as the address pointed to by foo remains unchanged, the following expression will also be true:


*foo == myvar


Declaring pointers
Due to the ability of a pointer to directly refer to the value that it points to, a pointer has different properties when it points to a char than when it points to an int or a float. Once dereferenced, the type needs to be known. And for that, the declaration of a pointer needs to include the data type the pointer is going to point to.

The declaration of pointers follows this syntax:

type * name;

where type is the data type pointed to by the pointer. This type is not the type of the pointer itself, but the type of the data the pointer points to. For example:

1
2
3
int * number;
char * character;
double * decimals;


These are three declarations of pointers. Each one is intended to point to a different data type, but, in fact, all of them are pointers and all of them are likely going to occupy the same amount of space in memory (the size in memory of a pointer depends on the platform where the program runs). Nevertheless, the data to which they point to do not occupy the same amount of space nor are of the same type: the first one points to an int, the second one to a char, and the last one to a double. Therefore, although these three example variables are all of them pointers, they actually have different types: int*, char*, and double* respectively, depending on the type they point to.

Note that the asterisk (*) used when declaring a pointer only means that it is a pointer (it is part of its type compound specifier), and should not be confused with the dereference operator seen a bit earlier, but which is also written with an asterisk (*). They are simply two different things represented with the same sign.

Let's see an example on pointers:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// my first pointer
#include
using namespace std;

int main ()
{
int firstvalue, secondvalue;
int * mypointer;

mypointer = &firstvalue;
*mypointer = 10;
mypointer = &secondvalue;
*mypointer = 20;
cout

Kết quả (Việt) 1:

Con trỏTrong chương trước đó, biến đã được giải thích như các vị trí trong bộ nhớ của máy tính mà có thể được truy cập bằng mã định danh của họ (tên của họ). Bằng cách này, chương trình không cần phải quan tâm đến địa chỉ vật lý của các dữ liệu trong bộ nhớ; nó chỉ đơn giản là sử dụng các định danh bất cứ khi nào nó cần phải đề cập đến biến.Đối với một chương trình C++, bộ nhớ của máy tính là giống như một loạt các tế bào bộ nhớ, mỗi một byte Kích thước, và với một địa chỉ duy nhất. Các tế bào bộ nhớ đơn byte được sắp xếp theo một cách mà cho phép dữ liệu đại diện lớn hơn một byte để chiếm tế bào bộ nhớ có liên tiếp địa chỉ.Bằng cách này, mỗi tế bào có thể được dễ dàng đặt trong bộ nhớ bằng phương tiện của địa chỉ duy nhất của nó. Ví dụ, các tế bào bộ nhớ với địa chỉ 1776 luôn luôn sau ngay sau khi các tế bào với địa chỉ năm 1775 đến trước một với năm 1777, và là chính xác một ngàn các tế bào sau khi tế bào 776 và chính xác một ngàn trước khi 2776.Khi một biến bùng nổ, bộ nhớ cần thiết để lưu trữ giá trị của nó được phân công một địa điểm cụ thể trong bộ nhớ (địa chỉ bộ nhớ của nó). Nói chung, chương trình C++ không tích cực quyết các địa chỉ bộ nhớ chính xác nơi các biến được lưu trữ. May mắn thay, nhiệm vụ đó là trái với môi trường nơi mà chương trình chạy - nói chung, Hệ điều hành quyết định các vị trí cụ thể bộ nhớ trên thời gian chạy. Tuy nhiên, nó có thể hữu ích cho một chương trình để có thể để có được địa chỉ của một biến trong thời gian chạy để truy cập vào dữ liệu các tế bào đang ở một vị trí nhất định liên quan đến nó.Địa chỉ của nhà điều hành (&)Địa chỉ của một biến có thể được thu được bằng ngay trước tên của một biến với một dấu hiệu dấu "và" (&), được gọi là địa chỉ của nhà điều hành. Ví dụ: foo = & myvar;Điều này sẽ chỉ định địa chỉ của biến myvar cho foo; bởi ngay trước tên của biến myvar với địa chỉ của nhà điều hành (&), chúng tôi không còn cho nội dung của biến riêng của mình để foo, nhưng địa chỉ của nó.Địa chỉ thực tế của một biến trong bộ nhớ không thể được biết đến trước khi thời gian chạy, nhưng hãy giả sử, để giúp làm rõ một số khái niệm, myvar đó được đặt trong thời gian chạy trong địa chỉ bộ nhớ năm 1776.Trong trường hợp này, hãy xem xét các đoạn mã sau đây:123myvar = 25;foo = & myvar;vaïch = myvar;Các giá trị chứa trong mỗi biến sau khi thực hiện điều này được thể hiện trong sơ đồ sau đây: Trước tiên, chúng tôi đã chỉ định giá trị 25 để myvar (một biến có địa chỉ trong bộ nhớ, chúng tôi giả định là 1776).Các báo cáo thứ hai gán foo địa chỉ myvar, chúng tôi đã giả định là năm 1776.Cuối cùng, tuyên bố thứ ba, chỉ định giá trị chứa trong myvar để bar. Đây là một hoạt động tiêu chuẩn phân công, như đã thực hiện nhiều lần trong chương trước đó.Sự khác biệt chính giữa những điều khoản về thứ hai và thứ ba là sự xuất hiện của các địa chỉ của nhà điều hành (&).Biến mà các cửa hàng địa chỉ của một biến (như foo trong ví dụ trước) là những gì trong C++ được gọi là một con trỏ. Con trỏ là một tính năng rất mạnh mẽ của ngôn ngữ mà có nhiều công dụng trong chương trình cấp thấp hơn. Một chút sau đó, chúng tôi sẽ xem làm thế nào để tuyên bố và sử dụng con trỏ.Trỏ nhà điều hành (*)Như đã chỉ thấy, một biến mà các cửa hàng địa chỉ của một biến được gọi là một con trỏ. Con trỏ được cho là "điểm đến" thay đổi địa chỉ mà họ lưu trữ.Một bất động sản thú vị của con trỏ là họ có thể được sử dụng để truy cập vào các biến họ chỉ trực tiếp. Điều này được thực hiện bởi ngay trước tên con trỏ với các nhà điều hành dereference (*). Các nhà điều hành chính nó có thể được đọc như "giá trị được chỉ tới bởi".Vì vậy, sau đây với giá trị của các ví dụ trước đó, các tuyên bố sau: Baz = * foo;Điều này có thể được đọc như: "baz bằng giá trị chỉ tới bởi foo", và tuyên bố sẽ thực sự chỉ định giá trị 25 cho baz, kể từ khi foo là năm 1776, và giá trị được chỉ tới bởi 1776 (sau ví dụ ở trên) sẽ là 25. Nó là quan trọng để phân biệt rõ ràng mà foo đề cập đến giá trị năm 1776, trong khi * foo (với dấu hoa thị * ngay trước các định danh) đề cập đến các giá trị được lưu trữ tại địa chỉ năm 1776, mà trong trường hợp này là 25. Nhận thấy sự khác biệt của bao gồm hoặc không bao gồm các nhà điều hành dereference (tôi đã thêm một bình luận giải thích như thế nào mỗi hai biểu thức có thể được đọc): 12Baz = foo; Baz bằng foo (1776)Baz = * foo; Baz bằng giá trị được chỉ tới bởi foo (25) Tham khảo và trỏ nhà khai thác được như vậy, bổ sung:& là địa chỉ của nhà điều hành, và có thể được đọc đơn giản là "địa chỉ"* đang sử dụng dereference nhiều, và có thể được đọc như "giá trị được chỉ tới bởi"Vì vậy, họ có ý nghĩa đối diện loại: địa chỉ thu được với & có thể được dereferenced với *.Trước đó, chúng tôi thực hiện các hoạt động hai nhiệm vụ sau đây:12myvar = 25;foo = & myvar;Ngay sau khi các báo cáo hai, tất cả những biểu hiện sau sẽ cung cấp cho đúng như là kết quả:1234myvar == 25& myvar == năm 1776foo == năm 1776* foo == 25Các biểu hiện đầu tiên là khá rõ ràng, xem xét rằng các hoạt động chuyển nhượng thực hiện trên myvar là myvar = 25. Thứ hai sử dụng các địa chỉ của nhà điều hành (&), mà trả về địa chỉ myvar, mà chúng tôi cho rằng nó có giá trị năm 1776. Thứ 3 là phần nào rõ ràng, kể từ thứ hai biểu thức là đúng sự thật và đã là phân công hoạt động thực hiện trên foo foo = & myvar. Sử dụng biểu thức thứ tư các nhà điều hành dereference (*) mà có thể được đọc như là "giá trị được chỉ tới bởi", và giá trị được chỉ tới bởi foo thực sự là 25.Vì vậy, sau khi tất cả, bạn có thể cũng suy ra rằng đối với miễn là địa chỉ chỉ tới bởi foo vẫn không thay đổi, những biểu hiện sau đây sẽ cũng là đúng: * foo == myvarTuyên bố con trỏDue to the ability of a pointer to directly refer to the value that it points to, a pointer has different properties when it points to a char than when it points to an int or a float. Once dereferenced, the type needs to be known. And for that, the declaration of a pointer needs to include the data type the pointer is going to point to.The declaration of pointers follows this syntax:type * name; where type is the data type pointed to by the pointer. This type is not the type of the pointer itself, but the type of the data the pointer points to. For example:123int * number;char * character;double * decimals;These are three declarations of pointers. Each one is intended to point to a different data type, but, in fact, all of them are pointers and all of them are likely going to occupy the same amount of space in memory (the size in memory of a pointer depends on the platform where the program runs). Nevertheless, the data to which they point to do not occupy the same amount of space nor are of the same type: the first one points to an int, the second one to a char, and the last one to a double. Therefore, although these three example variables are all of them pointers, they actually have different types: int*, char*, and double* respectively, depending on the type they point to.Note that the asterisk (*) used when declaring a pointer only means that it is a pointer (it is part of its type compound specifier), and should not be confused with the dereference operator seen a bit earlier, but which is also written with an asterisk (*). They are simply two different things represented with the same sign.Let's see an example on pointers:1234567891011121314151617// my first pointer#include using namespace std;int main (){ int firstvalue, secondvalue; int * mypointer; mypointer = &firstvalue; *mypointer = 10; mypointer = &secondvalue; *mypointer = 20; cout << "firstvalue is " << firstvalue << '
'; cout << "secondvalue is " << secondvalue << '
'; return 0;}firstvalue is 10secondvalue is 20Edit & RunNotice that even though neither firstvalue nor secondvalue are directly set any value in the program, both end up with a value set indirectly through the use of mypointer. This is how it happens:First, mypointer is assigned the address of firstvalue using the address-of operator (&). Then, the value pointed to by mypointer is assigned a value of 10. Because, at this moment, mypointer is pointing to the memory location of firstvalue, this in fact modifies the value of firstvalue.In order to demonstrate that a pointer may point to different variables during its lifetime in a program, the example repeats the process with secondvalue and that same pointer, mypointer.
Here is an example a little bit more elaborated:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// more pointers
#include
using namespace std;

int main ()
{
int firstvalue = 5, secondvalue = 15;
int * p1, * p2;

p1 = &firstvalue; // p1 = address of firstvalue
p2 = &secondvalue; // p2 = address of secondvalue
*p1 = 10; // value pointed to by p1 = 10
*p2 = *p1; // value pointed to by p2 = value pointed to by p1
p1 = p2; // p1 = p2 (value of pointer is copied)
*p1 = 20; // value pointed to by p1 = 20

cout << "firstvalue is " << firstvalue << '
';
cout << "secondvalue is " << secondvalue << '
';
return 0;
}
firstvalue is 10
secondvalue is 20
Edit & Run


Each assignment operation includes a comment on how each line could be read: i.e., replacing ampersands (&) by "address of", and asterisks (*) by "value pointed to by".

Notice that there are expressions with pointers p1 and p2, both with and without the dereference operator (*). The meaning of an expression using the dereference operator (*) is very different from one that does not. When this operator precedes the pointer name, the expression refers to the value being pointed, while when a pointer name appears without this operator, it refers to the value of the pointer itself (i.e., the address of what the pointer is pointing to).

Another thing that may call your attention is the line:


int * p1, * p2;


This declares the two pointers used in the previous example. But notice that there is an asterisk (*) for each pointer, in order for both to have

Kết quả (Việt) 2:

Con trỏ
Trong chương trước, các biến đã được giải thích là vị trí trong bộ nhớ của máy tính mà có thể được truy cập bằng cách định danh của họ (tên của họ). Bằng cách này, các chương trình không cần quan tâm đến các địa chỉ vật lý của dữ liệu trong bộ nhớ; nó chỉ đơn giản là sử dụng từ định bất cứ khi nào nó cần phải tham khảo các biến. Đối với một chương trình C ++, bộ nhớ của máy tính giống như một chuỗi các tế bào bộ nhớ, mỗi một byte trong kích thước, và từng có một địa chỉ duy nhất. Những tế bào bộ nhớ single-byte được đặt hàng trong một cách mà cho phép trình bày dữ liệu lớn hơn một byte để chiếm các tế bào bộ nhớ có địa chỉ liên tiếp. Bằng cách này, mỗi tế bào có thể được dễ dàng nằm trong bộ nhớ bằng địa chỉ duy nhất của nó. Ví dụ, các tế bào bộ nhớ với địa chỉ 1776 luôn theo ngay sau khi các tế bào với địa chỉ 1775 và đi trước một với năm 1777, và là chính xác một ngàn tế bào sau khi 776 và chính xác một ngàn tế bào trước 2776. Khi một biến được khai báo, các bộ nhớ cần thiết để lưu trữ giá trị của nó được gán một địa điểm cụ thể trong bộ nhớ (địa chỉ bộ nhớ của nó). Nói chung, các chương trình C ++ không chủ động quyết định các địa chỉ bộ nhớ chính xác nơi các biến của nó được lưu trữ. May mắn thay, nhiệm vụ này là trái với các môi trường mà chương trình được chạy - nói chung, một hệ điều hành mà quyết định các vị trí nhớ đặc biệt vào thời gian chạy. Tuy nhiên, nó có thể hữu ích cho một chương trình để có thể có được địa chỉ của một biến trong thời gian chạy để truy cập vào các tế bào dữ liệu mà đang ở một vị trí tương đối nhất định với nó. Địa chỉ-nhà điều hành (&) Địa chỉ của một biến thể thể thu được bằng cách đặt trước tên của một biến với một dấu và (&), được biết đến như là địa chỉ của nhà điều hành. Ví dụ: foo = & myvar; này sẽ gán địa chỉ của biến myvar để foo; bằng cách đặt trước tên của myvar biến với địa chỉ của nhà điều hành (&), chúng ta không còn gán nội dung của biến đó để foo, nhưng địa chỉ của nó. Các địa chỉ thực của một biến trong bộ nhớ có thể không được biết đến trước khi thời gian chạy, nhưng chúng ta hãy giả định, để giúp làm rõ một số khái niệm, myvar được đặt trong thời gian chạy trong các địa chỉ bộ nhớ năm 1776. Trong trường hợp này, hãy xem xét các đoạn mã sau: 1 2 3 myvar = 25; foo = & myvar; bar = myvar; Các giá trị chứa trong mỗi biến sau khi thực hiện điều này được thể hiện trong sơ đồ sau đây:. Đầu tiên, chúng ta gán giá trị 25 để myVar (một biến có địa chỉ trong bộ nhớ chúng ta giả định là 1776) Các câu lệnh thứ hai gán foo địa chỉ của myvar , mà chúng ta đã giả định là năm 1776. Cuối cùng, câu lệnh thứ ba, gán giá trị chứa trong myvar đến quán bar. Đây là một hoạt động chuyển nhượng tiêu chuẩn, như đã được thực hiện nhiều lần trong các chương trước. Sự khác biệt chính giữa các báo cáo thứ hai và thứ ba là sự xuất hiện của các địa chỉ của các nhà điều hành (&). Các biến lưu trữ địa chỉ của một biến khác (như foo trong ví dụ trước) là gì trong C ++ được gọi là một con trỏ. Con trỏ là một tính năng rất mạnh của ngôn ngữ mà có nhiều công dụng trong lập trình cấp thấp hơn. Một lát sau, chúng tôi sẽ xem làm thế nào để khai báo và sử dụng con trỏ. Toán tử tham chiếu (*) Như vừa thấy, một biến mà các cửa hàng địa chỉ của một biến khác được gọi là một con trỏ. Con trỏ được cho là "điểm đến" biến mà địa chỉ của họ lưu trữ. Một tính chất thú vị của con trỏ là chúng có thể được sử dụng để truy cập các biến mà nó trỏ tới trực tiếp. Điều này được thực hiện bằng cách đặt trước tên con trỏ với các toán tử tham chiếu (*). Các nhà điều hành chính nó có thể được đọc là "giá trị được trỏ đến bởi". Vì vậy, sau đây với các giá trị của các ví dụ trước, các phát biểu sau đây: baz = * foo; Điều này có thể được đọc như: "baz bằng giá trị được trỏ đến bởi foo" , và tuyên bố sẽ thực sự gán giá trị 25 để Baz, kể từ foo là năm 1776, và các giá trị được trỏ đến bởi năm 1776 (sau đây ví dụ trên) sẽ là 25. Điều quan trọng là phải phân biệt rõ ràng foo mà đề cập đến giá trị năm 1776, trong khi * foo (với một dấu * trước tên) đề cập đến các giá trị được lưu trữ tại địa chỉ 1776, mà trong trường hợp này là 25. Chú ý sự khác biệt của bao gồm hoặc không bao gồm các toán tử tham chiếu (Tôi đã thêm một lời chú thích của từng người trong số này hai biểu thức có thể đọc được): 1 2 baz = foo; // Baz bằng foo (1776) baz = * foo; // Baz bằng giá trị được trỏ đến bởi foo (25) Các toán tử tham chiếu và tới đích là như vậy, bổ sung: & là địa chỉ của nhà điều hành, và có thể được đọc đơn giản là "địa chỉ của" * là toán tử tham chiếu, và có thể được đọc là "giá trị được trỏ đến bởi". Vì vậy, họ có loại ngược lại ý nghĩa: Một địa chỉ thu được và có thể được dereferenced với * Trước đó, chúng tôi thực hiện hai hoạt động phân cấp như sau: 1 2 myvar = 25; foo = & myvar; Ngay sau khi những hai báo cáo, tất cả các biểu thức sau đây sẽ cung cấp cho đúng kết quả: 1 2 3 4 myvar == 25 & myvar == 1776 foo == 1776 * foo == 25 Những biểu hiện đầu tiên là khá rõ ràng, xem xét rằng các hoạt động chuyển nhượng thực hiện trên myvar là myvar = 25. Điều thứ hai sử dụng các địa chỉ của các nhà điều hành (&), trả về địa chỉ của myvar, mà chúng tôi cho rằng nó có một giá trị của năm 1776. Người thứ ba là phần nào rõ ràng, từ biểu thức thứ hai là sự thật và các hoạt động chuyển nhượng thực hiện trên foo là foo = & myvar. Các biểu hiện thứ tư sử dụng các toán tử tham chiếu (*) có thể được đọc là "giá trị được trỏ đến bởi", và các giá trị được trỏ đến bởi foo thực sự là 25. Vì vậy, sau khi tất cả điều đó, bạn cũng có thể suy ra rằng càng lâu càng địa chỉ trỏ đến bởi foo vẫn không thay đổi, các biểu hiện sau đây cũng sẽ là sự thật: * foo == myvar Khai báo con trỏ Do khả năng của một con trỏ để trực tiếp tham khảo các giá trị mà nó trỏ tới, một con trỏ có đặc tính khác nhau khi nó trỏ tới một char hơn khi nó trỏ tới một int hay float. Khi dereferenced, các loại cần phải được biết đến. . Và cho rằng, tuyên bố của một con trỏ cần phải bao gồm các kiểu dữ liệu con trỏ sẽ trỏ đến Tuyên bố của các con trỏ sau này cú pháp: loại * Tên; trong đó type là kiểu dữ liệu được trỏ đến bởi con trỏ. Loại này không phải là kiểu của con trỏ chính nó, nhưng các kiểu dữ liệu con trỏ trỏ tới. Ví dụ: 1 2 3 int * số; char * nhân vật; double * thập phân; Đây là ba khai báo của con trỏ. Mỗi người được dự định để trỏ đến một kiểu dữ liệu khác nhau, nhưng, trên thực tế, tất cả chúng đều là con trỏ và tất cả chúng có khả năng sẽ chiếm cùng một lượng không gian trong bộ nhớ (kích thước trong bộ nhớ của một con trỏ tùy thuộc vào nền tảng nơi mà các chương trình chạy). Tuy nhiên, những dữ liệu mà chúng trỏ tới không chiếm cùng một lượng không gian cũng không phải là cùng loại: một trong những điểm đầu tiên để một int, điều thứ hai đến một char, và là người cuối cùng một đôi. Vì vậy, mặc dù ba biến ví dụ là tất cả chúng con trỏ, họ thực sự có nhiều loại khác nhau: int *, char *, và đôi * tương ứng, tùy thuộc vào loại chúng trỏ đến. Lưu ý rằng các dấu hoa thị (*) được sử dụng khi khai báo một con trỏ chỉ có nghĩa là nó là một con trỏ (nó là một phần của các loại hợp chất đặc tả của nó), và không nên nhầm lẫn với các toán tử tham chiếu nhìn thấy sớm hơn một chút, nhưng mà cũng được viết với một dấu sao (*). Họ chỉ đơn giản là hai việc khác nhau đại diện cho cùng một dấu. Chúng ta hãy xem một ví dụ về con trỏ: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 // con trỏ đầu tiên của tôi #include












































































































































using namespace std; int main () {int firstvalue, secondvalue; int * mypointer; mypointer = & firstvalue; * mypointer = 10; mypointer = & secondvalue; * mypointer = 20; cout << "firstvalue là" << firstvalue << ' n '; cout << "secondvalue là" << secondvalue <<' n '; return 0;} firstvalue là 10 secondvalue là 20 Chỉnh sửa & Run Chú ý rằng mặc dù cả hai firstvalue cũng không secondvalue được trực tiếp đặt bất kỳ giá trị trong chương trình, cả hai kết thúc với một giá trị thiết lập một cách gián tiếp thông qua việc sử dụng các mypointer. Đây là cách nó xảy ra: Thứ nhất, mypointer được gán địa chỉ của firstvalue bằng cách sử dụng địa chỉ của nhà điều hành (&). Sau đó, các giá trị được trỏ đến bởi mypointer được gán giá trị là 10. Bởi vì, tại thời điểm này, mypointer đang trỏ đến vị trí nhớ của firstvalue, điều này trong thực tế thay đổi giá trị của firstvalue. Để chứng minh rằng một con trỏ có thể trỏ đến các biến khác nhau trong suốt cuộc đời của mình trong một chương trình, ví dụ lặp đi lặp lại quá trình với secondvalue và rằng cùng một con trỏ, mypointer. Dưới đây là một ví dụ một chút lập hơn: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 // more pointers #include

















































using namespace std; int main () {int firstvalue = 5, secondvalue = 15; int * p1, * p2; p1 = & firstvalue; // P1 = địa chỉ của firstvalue p2 = & secondvalue; // P2 = địa chỉ của secondvalue * p1 = 10; // Giá trị được trỏ đến bởi p1 = 10 * p2 = * p1; // Giá trị được trỏ đến bởi p2 = giá trị trỏ đến bởi p1 p1 = p2; // P1 = p2 (giá trị của con trỏ được sao chép) * p1 = 20; // Giá trị được trỏ đến bởi p1 = 20 cout << "firstvalue là" << firstvalue << ' n'; cout << "secondvalue là" << secondvalue << ' n'; return 0;} firstvalue là 10 secondvalue là 20 Chỉnh sửa & Run Mỗi hoạt động chuyển nhượng bao gồm một lời nhận xét ​​về cách mỗi dòng có thể được đọc:. tức là, thay thế ký hiệu (&) bởi "địa chỉ của", và dấu hoa thị (*) bằng "giá trị được trỏ đến bởi" Chú ý rằng có biểu thức với các con trỏ p1 và p2, cả hai có và không có các toán tử tham chiếu (*). Ý nghĩa của một biểu thức bằng cách sử dụng toán tử tham chiếu (*) là rất khác nhau từ một trong những điều đó không. Khi điều hành này trước tên biến con trỏ, biểu đề cập đến những giá trị đang được chỉ, trong khi khi một tên con trỏ xuất hiện mà không điều hành này, nó đề cập đến giá trị của con trỏ chính nó (ví dụ, địa chỉ của những gì con trỏ đang trỏ tới). Một điều mà có thể bạn chú ý là dòng: int * p1, * p2; này khai báo hai con trỏ được sử dụng trong ví dụ trước. Nhưng cần chú ý rằng có một dấu sao (*) cho mỗi con trỏ, để cho cả hai để có