鐢盋/C++緙栬瘧鐨勭▼搴忓崰鐢ㄧ殑鍐呭瓨鍒嗕負(fù)浠ヤ笅鍑犱釜閮ㄥ垎
1銆佹爤鍖?stack)錛?鐢辯紪璇戝櫒鑷姩鍒嗛厤閲婃斁 錛屽瓨鏀懼嚱鏁扮殑鍙傛暟鍊鹼紝灞閮ㄥ彉閲忕殑鍊肩瓑銆傚叾鎿嶄綔鏂瑰紡綾諱技浜庢暟鎹粨鏋勪腑鐨勬爤銆?
2銆佸爢鍖?heap)錛?涓鑸敱紼嬪簭鍛樺垎閰嶉噴鏀撅紝 鑻ョ▼搴忓憳涓嶉噴鏀撅紝紼嬪簭緇撴潫鏃跺彲鑳界敱O(jiān)S鍥炴敹銆傛敞鎰忓畠涓庢暟鎹粨鏋勪腑鐨勫爢鏄袱鍥炰簨錛屽垎閰嶆柟寮忓掓槸綾諱技浜庨摼琛ㄣ?
3銆佸叏灞鍖?static)錛?鍏ㄥ眬鍙橀噺鍜岄潤鎬佸彉閲忕殑瀛樺偍鏄斁鍦ㄤ竴鍧楃殑錛屽垵濮嬪寲鐨勫叏灞鍙橀噺鍜岄潤鎬佸彉閲忓湪涓鍧楀尯鍩燂紝 鏈垵濮嬪寲鐨勫叏灞鍙橀噺鍜屾湭鍒濆鍖栫殑闈欐佸彉閲忓湪鐩擱偦鐨勫彟涓鍧楀尯鍩燂紝紼嬪簭緇撴潫鍚庢湁緋葷粺閲婃斁 銆?
4銆佹枃瀛楀父閲忓尯錛?甯擱噺瀛楃涓插氨鏄斁鍦ㄨ繖閲岀殑錛?紼嬪簭緇撴潫鍚庣敱緋葷粺閲婃斁銆?
5銆佺▼搴忎唬鐮佸尯錛?瀛樻斁鍑芥暟浣撶殑浜岃繘鍒朵唬鐮併?
Example:
int a = 0; // 鍏ㄥ眬鍒濆鍖栧尯
char *p1; // 鍏ㄥ眬鏈垵濮嬪寲鍖?
main()
{
int b; // 鏍?
char s[] = "abc"; // 鏍?
char *p2; // 鏍?
char *p3 = "123456"; // 123456\0鍦ㄥ父閲忓尯錛宲3鍦ㄦ爤涓娿?
static int c =0錛?// 鍏ㄥ眬(闈欐?鍒濆鍖栧尯
p1 = (char *)malloc(10);
p2 = (char *)malloc(20); // 鍒嗛厤寰楁潵寰?0鍜?0瀛楄妭鐨勫尯鍩熷氨鍦ㄥ爢鍖恒?
strcpy(p1, "123456"); // 123456\0鏀懼湪甯擱噺鍖猴紝緙栬瘧鍣ㄥ彲鑳戒細(xì)灝嗗畠涓巔3鎵鎸囧悜鐨?123456"浼樺寲鎴愪竴涓湴鏂廣?
}
浜屻佸爢鍜屾爤鐨勭悊璁虹煡璇?
2.1 鐢寵鏂瑰紡
鏍? 鐢辯郴緇熻嚜鍔ㄥ垎閰嶃?渚嬪錛屽０鏄庡湪鍑芥暟涓竴涓眬閮ㄥ彉閲?int b; 緋葷粺鑷姩鍦ㄦ爤涓負(fù)b寮杈熺┖闂?
鍫? 闇瑕佺▼搴忓憳鑷繁鐢寵錛屽茍鎸囨槑澶у皬錛屽湪c涓璵alloc鍑芥暟錛氬p1 = (char *)malloc(10); 鍦–++涓敤new榪愮畻絎?濡俻2 = (char *)malloc(10); 浣嗘槸娉ㄦ剰p1銆乸2鏈韓鏄湪鏍堜腑鐨勩?
2.2 鐢寵鍚庣郴緇熺殑鍝嶅簲
鏍堬細(xì)鍙鏍堢殑鍓╀綑絀洪棿澶т簬鎵鐢寵絀洪棿錛岀郴緇熷皢涓虹▼搴忔彁渚涘唴瀛橈紝鍚﹀垯灝嗘姤寮傚父鎻愮ず鏍堟孩鍑恒?
鍫嗭細(xì)棣栧厛搴旇鐭ラ亾鎿嶄綔緋葷粺鏈変竴涓褰曠┖闂插唴瀛樺湴鍧鐨勯摼琛紝褰撶郴緇熸敹鍒扮▼搴忕殑鐢寵鏃訛紝 浼?xì)閬嶅巻璇ラ摼琛ㄥQ屽鎵劇涓涓┖闂村ぇ浜庢墍鐢寵絀洪棿鐨勫爢緇撶偣錛岀劧鍚庡皢璇ョ粨鐐逛粠絀洪棽緇撶偣閾捐〃涓垹闄わ紝騫跺皢璇ョ粨鐐圭殑絀洪棿鍒嗛厤緇欑▼搴忥紝鍙﹀錛屽浜庡ぇ澶氭暟緋葷粺錛屼細(xì)鍦ㄨ繖鍧? 鍐呭瓨絀洪棿涓殑棣栧湴鍧澶勮褰曟湰嬈″垎閰嶇殑澶у皬錛岃繖鏍鳳紝浠ｇ爜涓殑delete璇彞鎵嶈兘姝ｇ‘鐨勯噴鏀炬湰鍐呭瓨絀洪棿銆傚彟澶栵紝鐢變簬鎵懼埌鐨勫爢緇撶偣鐨勫ぇ灝忎笉涓瀹氭濂界瓑浜庣敵璇風(fēng)殑 澶у皬錛岀郴緇熶細(xì)鑷姩鐨勫皢澶氫綑鐨勯偅閮ㄥ垎閲嶆柊鏀懼叆絀洪棽閾捐〃涓?
2.3 鐢寵澶у皬鐨勯檺鍒?
鏍堬細(xì)鍦╓indows涓?鏍堟槸鍚戜綆鍦板潃鎵╁睍鐨勬暟鎹粨鏋勶紝鏄竴鍧楄繛緇殑鍐呭瓨鍖哄煙銆傝繖鍙ヨ瘽鐨勬剰鎬濇槸鏍堥《鐨勫湴鍧鍜屾爤鐨勬渶澶у閲忔槸緋葷粺棰勫厛瑙勫畾濂界殑錛屽湪 WINDOWS涓嬶紝鏍堢殑澶у皬鏄?M(涔熸湁鐨勮鏄?M錛屾諱箣鏄竴涓紪璇戞椂灝辯‘瀹氱殑甯告暟)錛屽鏋滅敵璇風(fēng)殑絀洪棿瓚呰繃鏍堢殑鍓╀綑絀洪棿鏃訛紝灝嗘彁紺簅verflow銆傚洜 姝わ紝鑳戒粠鏍堣幏寰楃殑絀洪棿杈冨皬銆?
鍫嗭細(xì)鍫嗘槸鍚戦珮鍦板潃鎵╁睍鐨勬暟鎹粨鏋勶紝鏄笉榪炵畫鐨勫唴瀛樺尯鍩熴傝繖鏄敱浜庣郴緇熸槸鐢ㄩ摼琛ㄦ潵瀛樺偍鐨勭┖闂插唴瀛樺湴鍧鐨勶紝鑷劧鏄笉榪炵畫鐨勶紝鑰岄摼琛ㄧ殑閬嶅巻鏂瑰悜鏄敱浣庡湴鍧鍚戦珮鍦板潃銆傚爢鐨勫ぇ灝忓彈闄愪簬璁＄畻鏈虹郴緇熶腑鏈夋晥鐨勮櫄鎷熷唴瀛樸傜敱姝ゅ彲瑙侊紝鍫嗚幏寰楃殑絀洪棿姣旇緝鐏墊椿錛屼篃姣旇緝澶с?
2.4 鐢寵鏁堢巼鐨勬瘮杈冿細(xì)
鏍堬細(xì)鐢辯郴緇熻嚜鍔ㄥ垎閰嶏紝閫熷害杈冨揩銆備絾紼嬪簭鍛樻槸鏃犳硶鎺у埗鐨勩?
鍫嗭細(xì)鏄敱new鍒嗛厤鐨勫唴瀛橈紝涓鑸熷害姣旇緝鎱紝鑰屼笖瀹規(guī)槗浜х敓鍐呭瓨紕庣墖,涓嶈繃鐢ㄨ搗鏉ユ渶鏂逛究銆?
鍙﹀錛屽湪WINDOWS涓嬶紝鏈濂界殑鏂瑰紡鏄敤VirtualAlloc鍒嗛厤鍐呭瓨錛屼粬涓嶆槸鍦ㄥ爢錛屼篃涓嶆槸鍦ㄦ爤鏄洿鎺ュ湪榪涚▼鐨勫湴鍧絀洪棿涓繚鐣欎竴蹇唴瀛橈紝铏界劧鐢ㄨ搗鏉ユ渶涓嶆柟渚褲備絾鏄熷害蹇紝涔熸渶鐏墊椿銆?
2.5 鍫嗗拰鏍堜腑鐨勫瓨鍌ㄥ唴瀹?
鏍堬細(xì) 鍦ㄥ嚱鏁拌皟鐢ㄦ椂錛岀涓涓繘鏍堢殑鏄富鍑芥暟涓悗鐨勪笅涓鏉℃寚浠?鍑芥暟璋冪敤璇彞鐨勪笅涓鏉″彲鎵ц璇彞)鐨勫湴鍧錛岀劧鍚庢槸鍑芥暟鐨勫悇涓弬鏁幫紝鍦ㄥぇ澶氭暟鐨凜緙栬瘧鍣ㄤ腑錛屽弬鏁版槸鐢? 鍙沖線宸﹀叆鏍堢殑錛岀劧鍚庢槸鍑芥暟涓殑灞閮ㄥ彉閲忋傛敞鎰忛潤鎬佸彉閲忔槸涓嶅叆鏍堢殑銆傚綋鏈鍑芥暟璋冪敤緇撴潫鍚庯紝灞閮ㄥ彉閲忓厛鍑烘爤錛岀劧鍚庢槸鍙傛暟錛屾渶鍚庢爤欏舵寚閽堟寚鍚戞渶寮濮嬪瓨鐨勫湴鍧錛? 涔熷氨鏄富鍑芥暟涓殑涓嬩竴鏉℃寚浠わ紝紼嬪簭鐢辮鐐圭戶緇繍琛屻?
鍫嗭細(xì)涓鑸槸鍦ㄥ爢鐨勫ご閮ㄧ敤涓涓瓧鑺傚瓨鏀懼爢鐨勫ぇ灝忋傚爢涓殑鍏蜂綋鍐呭鏈夌▼搴忓憳瀹夋帓銆?
2.6 瀛樺彇鏁堢巼鐨勬瘮杈?
char s1[] = "aaaaaaaaaaaaaaa";
char *s2 = "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa鏄湪榪愯鏃跺埢璧嬪肩殑錛?
鑰宐bbbbbbbbbb鏄湪緙栬瘧鏃跺氨紜畾鐨勶紱
浣嗘槸錛屽湪浠ュ悗鐨勫瓨鍙栦腑錛屽湪鏍堜笂鐨勬暟緇勬瘮鎸囬拡鎵鎸囧悜鐨勫瓧絎︿覆(渚嬪鍫?蹇?
姣斿錛?
#include
void main()
{
char a = 1;
char c[] = "1234567890";
char *p ="1234567890";
a = c[1];
a = p[1];
return;
}
瀵瑰簲鐨勬眹緙栦唬鐮?
10: a = c[1];
00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]
0040106A 88 4D FC mov byte ptr [ebp-4],cl
11: a = p[1];
0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]
00401070 8A 42 01 mov al,byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4],al
絎竴縐嶅湪璇誨彇鏃剁洿鎺ュ氨鎶婂瓧絎︿覆涓殑鍏冪礌璇誨埌瀵勫瓨鍣╟l涓紝鑰岀浜岀鍒欒鍏堟妸鎸囬拡鍊艱鍒癳dx涓紝鍦ㄦ牴鎹甧dx璇誨彇瀛楃錛屾樉鐒舵參浜嗐?
2.7 灝忕粨錛?
鍫嗗拰鏍堢殑鍖哄埆鍙互鐢ㄥ涓嬬殑姣斿柣鏉ョ湅鍑猴細(xì) 浣跨敤鏍堝氨璞℃垜浠幓楗閲屽悆楗紝鍙鐐硅彍(鍙戝嚭鐢寵)銆佷粯閽便佸拰鍚?浣跨敤)錛屽悆楗變簡灝辮蛋錛屼笉蹇呯悊浼?xì)鍒囪彍銆佹礂鑿滅瓑鍑嗗宸ヤ綔鍜屾礂紕椼佸埛閿呯瓑鎵熬宸ヤ綔錛屼粬鐨勫ソ澶勬槸 蹇嵎錛屼絾鏄嚜鐢卞害灝忋?浣跨敤鍫嗗氨璞℃槸鑷繁鍔ㄦ墜鍋氬枩嬈㈠悆鐨勮彍鑲達(dá)紝姣旇緝楹葷儲錛屼絾鏄瘮杈冪鍚堣嚜宸辯殑鍙ｅ懗錛岃屼笖鑷敱搴﹀ぇ銆?
榪樻湁灝辨槸鍑芥暟璋冪敤鏃朵細(xì)鍦ㄦ爤涓婃湁涓緋誨垪鐨勪繚鐣欑幇鍦哄強(qiáng)浼犻掑弬鏁扮殑鎿嶄綔銆傛爤鐨勭┖闂村ぇ灝忔湁闄愬畾錛孷C鐨勭己鐪佹槸2M銆傛爤涓嶅鐢ㄧ殑鎯呭喌涓鑸槸紼嬪簭涓垎閰嶄簡澶ч噺鏁扮粍鍜岄? 褰掑嚱鏁板眰嬈″お娣便傛湁涓鐐瑰繀欏葷煡閬擄紝褰撲竴涓嚱鏁拌皟鐢ㄥ畬榪斿洖鍚庡畠浼?xì)閲婃斁璇ュ嚱鏁颁腑鎵鏈夌殑鏍堢┖闂淬傛爤鏄敱緙栬瘧鍣ㄨ嚜鍔ㄧ鐞嗙殑錛屼笉鐢ㄤ綘鎿嶅績銆傚爢鏄姩鎬佸垎閰嶅唴瀛樼殑錛屽茍涓? 浣犲彲浠ュ垎閰嶄嬌鐢ㄥ緢澶х殑鍐呭瓨銆備絾鏄敤涓嶅ソ浼?xì)漶旂敓鍐呭瓨娉勬紡銆傚茍涓旈綣佸湴malloc鍜宖ree浼?xì)漶旂敓鍐呭瓨纰庣?鏈夌偣綾諱技紓佺洏紕庣墖)錛屽洜涓篊鍒嗛厤鍔ㄦ佸唴瀛樻椂鏄 鎵懼尮閰嶇殑鍐呭瓨鐨勩傝岀敤鏍堝垯涓嶄細(xì)浜х敓紕庣墖銆傚湪鏍堜笂瀛樺彇鏁版嵁姣旈氳繃鎸囬拡鍦ㄥ爢涓婂瓨鍙栨暟鎹揩浜涖備竴鑸ぇ瀹惰鐨勫爢鏍堝拰鏍堟槸涓鏍風(fēng)殑錛屽氨鏄爤(stack)錛岃岃鍫嗘椂鎵? 鏄爢heap銆傛爤鏄厛鍏ュ悗鍑虹殑錛屼竴鑸槸鐢遍珮鍦板潃鍚戜綆鍦板潃鐢熼暱銆?br />
鎽樿嚜錛歨ttp://linux.chinaunix.net/bbs/thread-1119653-1-1.html
]]>
The memory of your computer can be imagined as a succession of memory cells, each one of the minimal size that computers manage (one byte). These single-byte memory cells are numbered in a consecutive way, so as, within any block of memory, every cell has the same number as the previous one plus one.
This way, each cell can be easily located in the memory because it has a unique address and all the memory cells follow a successive pattern. For example, if we are looking for cell 1776 we know that it is going to be right between cells 1775 and 1777, exactly one thousand cells after 776 and exactly one thousand cells before cell 2776.
Reference operator (&)
As soon as we declare a variable, the amount of memory needed is assigned for it at a specific location in memory (its memory address). We generally do not actively decide the exact location of the variable within the panel of cells that we have imagined the memory to be - Fortunately, that is a task automatically performed by the operating system during runtime. However, in some cases we may be interested in knowing the address where our variable is being stored during runtime in order to operate with relative positions to it.The address that locates a variable within memory is what we call a reference to that variable. This reference to a variable can be obtained by preceding the identifier of a variable with an ampersand sign (&), known as reference operator, and which can be literally translated as "address of". For example:
ted = &andy; |
This would assign to ted the address of variable andy, since when preceding the name of the variable andy with the reference operator (&) we are no longer talking about the content of the variable itself, but about its reference (i.e., its address in memory).
From now on we are going to assume that andy is placed during runtime in the memory address 1776. This number (1776) is just an arbitrary assumption we are inventing right now in order to help clarify some concepts in this tutorial, but in reality, we cannot know before runtime the real value the address of a variable will have in memory.
Consider the following code fragment:
andy = 25; |
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 andy (a variable whose address in memory we have assumed to be 1776).
The second statement copied to fred the content of variable andy (which is 25). This is a standard assignment operation, as we have done so many times before.
Finally, the third statement copies to ted not the value contained in andy but a reference to it (i.e., its address, which we have assumed to be 1776). The reason is that in this third assignment operation we have preceded the identifier andy with the reference operator (&), so we were no longer referring to the value of andy but to its reference (its address in memory).
The variable that stores the reference to another variable (like ted in the previous example) is what we call a pointer. Pointers are a very powerful feature of the C++ language that has many uses in advanced programming. Farther ahead, we will see how this type of variable is used and declared.
Dereference operator (*)
We have just seen that a variable which stores a reference to another variable is called a pointer. Pointers are said to "point to" the variable whose reference they store.
Using a pointer we can directly access the value stored in the variable which it points to. To do this, we simply have to precede the pointer's identifier with an asterisk (*), which acts as dereference operator and that can be literally translated to "value pointed by".
Therefore, following with the values of the previous example, if we write:
beth = *ted; |
(that we could read as: "beth equal to value pointed by ted") beth would take the value 25, since ted is 1776, and the value pointed by 1776 is 25.
You must clearly differentiate that the expression ted refers to the value 1776, while *ted (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 included an explanatory commentary of how each of these two expressions could be read):
beth = ted; // beth equal to ted ( 1776 ) |
Notice the difference between the reference and dereference operators:
- & is the reference operator and can be read as "address of"
- * is the dereference operator and can be read as "value pointed by"
Earlier we performed the following two assignment operations:
andy = 25; |
Right after these two statements, all of the following expressions would give true as result:
andy == 25 |
The first expression is quite clear considering that the assignment operation performed on andy was andy=25. The second one uses the reference operator (&), which returns the address of variable andy, 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 ted was ted=&andy. The fourth expression uses the dereference operator (*) that, as we have just seen, can be read as "value pointed by", and the value pointed by ted is indeed 25.
So, after all that, you may also infer that for as long as the address pointed by ted remains unchanged the following expression will also be true:
*ted == andy |
Declaring variables of pointer types
Due to the ability of a pointer to directly refer to the value that it points to, it becomes necessary to specify in its declaration which data type a pointer is going to point to. It is not the same thing to point to a char as to point to an int or a float.The declaration of pointers follows this format:
type * name;
where type is the data type of the value that the pointer is intended to point to. This type is not the type of the pointer itself! but the type of the data the pointer points to. For example:
int * number; |
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 will occupy the same amount of space in memory (the size in memory of a pointer depends on the platform where the code is going to run). 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 float. Therefore, although these three example variables are all of them pointers which occupy the same size in memory, they are said to have different types: int*, char* and float* respectively, depending on the type they point to.
I want to emphasize that the asterisk sign (*) that we use 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 that we have seen a bit earlier, but which is also written with an asterisk (*). They are simply two different things represented with the same sign.
Now have a look at this code:
// my first pointer |
firstvalue is 10 |
Notice that even though we have never directly set a value to either firstvalue or secondvalue, both end up with a value set indirectly through the use of mypointer. This is the procedure:
First, we have assigned as value of mypointer a reference to firstvalue using the reference operator (&). And then we have assigned the value 10 to the memory location pointed by mypointer, that because at this moment is pointing to the memory location of firstvalue, this in fact modifies the value of firstvalue.
In order to demonstrate that a pointer may take several different values during the same program I have repeated the process with secondvalue and that same pointer, mypointer.
Here is an example a little bit more elaborated:
// more pointers |
firstvalue is 10 |
I have included as a comment on each line how the code can be read: ampersand (&) as "address of" and asterisk (*) as "value pointed by".
Notice that there are expressions with pointers p1 and p2, both with and without 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 type int* (pointer to int).
Otherwise, the type for the second variable declared in that line would have been int (and not int*) because of precedence relationships. If we had written:
int * p1, p2;
|
p1 would indeed have int* type, but p2 would have type int (spaces do not matter at all for this purpose). This is due to operator precedence rules. But anyway, simply remembering that you have to put one asterisk per pointer is enough for most pointer users.
Pointers and arrays
The concept of array is very much bound to the one of pointer. In fact, the identifier of an array is equivalent to the address of its first element, as a pointer is equivalent to the address of the first element that it points to, so in fact they are the same concept. For example, supposing these two declarations:
int numbers [20]; |
The following assignment operation would be valid:
p = numbers; |
After that, p and numbers would be equivalent and would have the same properties. The only difference is that we could change the value of pointer p by another one, whereas numbers will always point to the first of the 20 elements of type int with which it was defined. Therefore, unlike p, which is an ordinary pointer, numbers is an array, and an array can be considered a constant pointer. Therefore, the following allocation would not be valid:
numbers = p; |
Because numbers is an array, so it operates as a constant pointer, and we cannot assign values to constants.
Due to the characteristics of variables, all expressions that include pointers in the following example are perfectly valid:
// more pointers |
10, 20, 30, 40, 50, |
In the chapter about arrays we used brackets ([]) several times in order to specify the index of an element of the array to which we wanted to refer. Well, these bracket sign operators [] are also a dereference operator known as offset operator. They dereference the variable they follow just as * does, but they also add the number between brackets to the address being dereferenced. For example:
a[5] = 0; // a [offset of 5] = 0 |
These two expressions are equivalent and valid both if a is a pointer or if a is an array.
Pointer initialization
When declaring pointers we may want to explicitly specify which variable we want them to point to:
int number; |
The behavior of this code is equivalent to:
int number; |
When a pointer initialization takes place we are always assigning the reference value to where the pointer points (tommy), never the value being pointed (*tommy). You must consider that at the moment of declaring a pointer, the asterisk (*) indicates only that it is a pointer, it is not the dereference operator (although both use the same sign: *). Remember, they are two different functions of one sign. Thus, we must take care not to confuse the previous code with:
int number; |
that is incorrect, and anyway would not have much sense in this case if you think about it.
As in the case of arrays, the compiler allows the special case that we want to initialize the content at which the pointer points with constants at the same moment the pointer is declared:
char * terry = "hello"; |
In this case, memory space is reserved to contain "hello" and then a pointer to the first character of this memory block is assigned to terry. If we imagine that "hello" is stored at the memory locations that start at addresses 1702, we can represent the previous declaration as:
It is important to indicate that terry contains the value 1702, and not 'h' nor "hello", although 1702 indeed is the address of both of these.
The pointer terry points to a sequence of characters and can be read as if it was an array (remember that an array is just like a constant pointer). For example, we can access the fifth element of the array with any of these two expression:
*(terry+4) |
Both expressions have a value of 'o' (the fifth element of the array).
Pointer arithmetics
To conduct arithmetical operations on pointers is a little different than to conduct them on regular integer data types. To begin with, only addition and subtraction operations are allowed to be conducted with them, the others make no sense in the world of pointers. But both addition and subtraction have a different behavior with pointers according to the size of the data type to which they point.
When we saw the different fundamental data types, we saw that some occupy more or less space than others in the memory. For example, let's assume that in a given compiler for a specific machine, char takes 1 byte, short takes 2 bytes and long takes 4.
Suppose that we define three pointers in this compiler:
char *mychar; |
and that we know that they point to memory locations 1000, 2000 and 3000 respectively.
So if we write:
mychar++; |
mychar, as you may expect, would contain the value 1001. But not so obviously, myshort would contain the value 2002, and mylong would contain 3004, even though they have each been increased only once. The reason is that when adding one to a pointer we are making it to point to the following element of the same type with which it has been defined, and therefore the size in bytes of the type pointed is added to the pointer.
This is applicable both when adding and subtracting any number to a pointer. It would happen exactly the same if we write:
mychar = mychar + 1; |
Both the increase (++) and decrease (--) operators have greater operator precedence than the dereference operator (*), but both have a special behavior when used as suffix (the expression is evaluated with the value it had before being increased). Therefore, the following expression may lead to confusion:
*p++ |
Because ++ has greater precedence than *, this expression is equivalent to *(p++). Therefore, what it does is to increase the value of p (so it now points to the next element), but because ++ is used as postfix the whole expression is evaluated as the value pointed by the original reference (the address the pointer pointed to before being increased).
Notice the difference with:
(*p)++
Here, the expression would have been evaluated as the value pointed by p increased by one. The value of p (the pointer itself) would not be modified (what is being modified is what it is being pointed to by this pointer).
If we write:
*p++ = *q++; |
Because ++ has a higher precedence than *, both p and q are increased, but because both increase operators (++) are used as postfix and not prefix, the value assigned to *p is *q before both p and q are increased. And then both are increased. It would be roughly equivalent to:
*p = *q; |
Like always, I recommend you to use parentheses () in order to avoid unexpected results and to give more legibility to the code.
Pointers to pointers
C++ allows the use of pointers that point to pointers, that these, in its turn, point to data (or even to other pointers). In order to do that, we only need to add an asterisk (*) for each level of reference in their declarations:
char a; |
This, supposing the randomly chosen memory locations for each variable of 7230, 8092 and 10502, could be represented as:
The value of each variable is written inside each cell; under the cells are their respective addresses in memory.
The new thing in this example is variable c, which can be used in three different levels of indirection, each one of them would correspond to a different value:
- c has type char** and a value of 8092
- *c has type char* and a value of 7230
- **c has type char and a value of 'z'
void pointers
The void type of pointer is a special type of pointer. In C++, void represents the absence of type, so void pointers are pointers that point to a value that has no type (and thus also an undetermined length and undetermined dereference properties).This allows void pointers to point to any data type, from an integer value or a float to a string of characters. But in exchange they have a great limitation: the data pointed by them cannot be directly dereferenced (which is logical, since we have no type to dereference to), and for that reason we will always have to cast the address in the void pointer to some other pointer type that points to a concrete data type before dereferencing it.
One of its uses may be to pass generic parameters to a function:
// increaser |
y, 1603 |
sizeof is an operator integrated in the C++ language that returns the size in bytes of its parameter. For non-dynamic data types this value is a constant. Therefore, for example, sizeof(char) is 1, because char type is one byte long.
Null pointer
A null pointer is a regular pointer of any pointer type which has a special value that indicates that it is not pointing to any valid reference or memory address. This value is the result of type-casting the integer value zero to any pointer type.
int * p; |
Do not confuse null pointers with void pointers. A null pointer is a value that any pointer may take to represent that it is pointing to "nowhere", while a void pointer is a special type of pointer that can point to somewhere without a specific type. One refers to the value stored in the pointer itself and the other to the type of data it points to.
Pointers to functions
C++ allows operations with pointers to functions. The typical use of this is for passing a function as an argument to another function, since these cannot be passed dereferenced. In order to declare a pointer to a function we have to declare it like the prototype of the function except that the name of the function is enclosed between parentheses () and an asterisk (*) is inserted before the name:
// pointer to functions |
8 |
In the example, minus is a pointer to a function that has two parameters of type int. It is immediately assigned to point to the function subtraction, all in a single line:
int (* minus)(int,int) = subtraction; |
]]>