സി++ ലെ പോയിൻ്റർ

Hugo Bertrand

2024, ജൂൺ 22, ശനിയാഴ്‌ച 10:09:49 PM

C++ ലെ പോയിൻ്ററുകളും റഫറൻസുകളും മനസ്സിലാക്കുന്നു
മെമ്മറി നിയന്ത്രിക്കാനും വേരിയബിളുകൾ കാര്യക്ഷമമായി കൈകാര്യം ചെയ്യാനും ഡെവലപ്പർമാരെ പ്രാപ്തരാക്കുന്ന C++ ലെ അടിസ്ഥാന ആശയങ്ങളാണ് പോയിൻ്ററുകളും റഫറൻസുകളും. ഒപ്റ്റിമൈസ് ചെയ്തതും ബഗ് രഹിതവുമായ കോഡ് എഴുതുന്നതിന് അവ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ മനസ്സിലാക്കുന്നത് നിർണായകമാണ്.
ഈ ലേഖനത്തിൽ, പോയിൻ്റർ വേരിയബിളുകളും റഫറൻസ് വേരിയബിളുകളും തമ്മിലുള്ള പ്രധാന വ്യത്യാസങ്ങൾ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും, അവയുടെ വാക്യഘടന, ഉപയോഗം, വിവിധ പ്രോഗ്രാമിംഗ് സാഹചര്യങ്ങളിലെ പ്രത്യാഘാതങ്ങൾ എന്നിവ ഉൾപ്പെടുന്നു. അവസാനം, ഓരോന്നും എപ്പോൾ, എങ്ങനെ ഫലപ്രദമായി ഉപയോഗിക്കണമെന്ന് നിങ്ങൾക്ക് വ്യക്തമായ ഗ്രാഹ്യമുണ്ടാകും.

കമാൻഡ് വിവരണം

int* ptr = &a; ഒരു പോയിൻ്റർ വേരിയബിൾ പ്രഖ്യാപിക്കുകയും അതിന് 'a' എന്ന വേരിയബിളിൻ്റെ വിലാസം നൽകുകയും ചെയ്യുന്നു.

int& ref = b; 'b' എന്ന വേരിയബിളിനെ സൂചിപ്പിക്കുന്ന ഒരു റഫറൻസ് വേരിയബിൾ പ്രഖ്യാപിക്കുന്നു.

ptr = 10; 'ptr' ചൂണ്ടിക്കാണിച്ച വേരിയബിളിൻ്റെ മൂല്യം പരിഷ്ക്കരിക്കുന്നു.

ref = 10; 'ref' പരാമർശിക്കുന്ന വേരിയബിളിൻ്റെ മൂല്യം പരിഷ്‌ക്കരിക്കുന്നു.

void modifyPointer(int p) ഒരു പോയിൻ്ററിനെ ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് ഒരു പാരാമീറ്ററായി എടുക്കുന്ന ഫംഗ്ഷൻ.

void modifyReference(int& r) ഒരു പൂർണ്ണസംഖ്യയെ ഒരു പരാമീറ്ററായി എടുക്കുന്ന ഫംഗ്‌ഷൻ.

modifyPointer(&x); modifyPointer എന്ന ഫംഗ്‌ഷനെ വിളിക്കുകയും അതിലേക്ക് 'x' എന്ന വിലാസം നൽകുകയും ചെയ്യുന്നു.

modifyReference(y); ഫംഗ്‌ഷൻ modifyReference എന്ന് വിളിക്കുകയും റഫറൻസ് പ്രകാരം 'y' പാസ്സുചെയ്യുകയും ചെയ്യുന്നു.

കമാൻഡ്	വിവരണം
int* ptr = &a;	ഒരു പോയിൻ്റർ വേരിയബിൾ പ്രഖ്യാപിക്കുകയും അതിന് 'a' എന്ന വേരിയബിളിൻ്റെ വിലാസം നൽകുകയും ചെയ്യുന്നു.
int& ref = b;	'b' എന്ന വേരിയബിളിനെ സൂചിപ്പിക്കുന്ന ഒരു റഫറൻസ് വേരിയബിൾ പ്രഖ്യാപിക്കുന്നു.
*ptr = 10;	'ptr' ചൂണ്ടിക്കാണിച്ച വേരിയബിളിൻ്റെ മൂല്യം പരിഷ്ക്കരിക്കുന്നു.
ref = 10;	'ref' പരാമർശിക്കുന്ന വേരിയബിളിൻ്റെ മൂല്യം പരിഷ്‌ക്കരിക്കുന്നു.
void modifyPointer(int* p)	ഒരു പോയിൻ്ററിനെ ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് ഒരു പാരാമീറ്ററായി എടുക്കുന്ന ഫംഗ്ഷൻ.
void modifyReference(int& r)	ഒരു പൂർണ്ണസംഖ്യയെ ഒരു പരാമീറ്ററായി എടുക്കുന്ന ഫംഗ്‌ഷൻ.
modifyPointer(&x);	modifyPointer എന്ന ഫംഗ്‌ഷനെ വിളിക്കുകയും അതിലേക്ക് 'x' എന്ന വിലാസം നൽകുകയും ചെയ്യുന്നു.
modifyReference(y);	ഫംഗ്‌ഷൻ modifyReference എന്ന് വിളിക്കുകയും റഫറൻസ് പ്രകാരം 'y' പാസ്സുചെയ്യുകയും ചെയ്യുന്നു.

പോയിൻ്റർ, റഫറൻസ് ഉദാഹരണങ്ങളുടെ ആഴത്തിലുള്ള വിശകലനം

C++ ലെ പോയിൻ്ററുകളുടെ ഉപയോഗം ആദ്യ സ്ക്രിപ്റ്റ് കാണിക്കുന്നു. ചടങ്ങിൽ , ഞങ്ങൾ ഒരു പൂർണ്ണസംഖ്യ വേരിയബിൾ പ്രഖ്യാപിക്കുന്നു ഒരു പോയിൻ്റർ വേരിയബിളും എന്ന വിലാസം കൈവശം വയ്ക്കുന്നു a. മൂല്യം കൈകാര്യം ചെയ്യാൻ ഇത് ഞങ്ങളെ അനുവദിക്കുന്നു പരോക്ഷമായി വഴി . സംഭരിച്ചിരിക്കുന്ന വിലാസത്തിലെ മൂല്യം മാറ്റുന്നതിലൂടെ , എന്നതിൻ്റെ മൂല്യവും ഞങ്ങൾ മാറ്റുന്നു a. ഡൈനാമിക് മെമ്മറി അലോക്കേഷൻ, ലിങ്ക്ഡ് ലിസ്റ്റുകൾ പോലെയുള്ള ഡാറ്റാ ഘടനകൾ, ഡയറക്ട് മെമ്മറി കൃത്രിമത്വം ആവശ്യമുള്ള ചില അൽഗോരിതങ്ങൾ നടപ്പിലാക്കൽ തുടങ്ങിയ സാഹചര്യങ്ങളിൽ ഉപയോഗപ്രദമായ, വേരിയബിളുകളുടെ പരോക്ഷ ആക്സസ് ചെയ്യുന്നതിനും പരിഷ്ക്കരിക്കുന്നതിനും പോയിൻ്ററുകൾ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഇത് കാണിക്കുന്നു.

സ്ക്രിപ്റ്റിൻ്റെ രണ്ടാം ഭാഗം C++ ലെ റഫറൻസുകൾ ചിത്രീകരിക്കുന്നു. ചടങ്ങ് ഒരു പൂർണ്ണസംഖ്യ വേരിയബിൾ പ്രഖ്യാപിക്കുന്നു ഒരു റഫറൻസ് വേരിയബിളും അത് നേരിട്ട് സൂചിപ്പിക്കുന്നു b. പരിഷ്ക്കരിക്കുന്നു യുടെ മൂല്യം നേരിട്ട് മാറ്റുന്നു . പോയിൻ്ററുകളിൽ നിന്ന് വ്യത്യസ്തമായി, റഫറൻസുകൾ അസാധുവാകാൻ കഴിയില്ല, ഡിക്ലയർ ചെയ്യുമ്പോൾ അവ ആരംഭിക്കുകയും വേണം. ഫംഗ്‌ഷൻ പാരാമീറ്ററുകൾ, ഒരു ഫംഗ്‌ഷനിൽ നിന്ന് ഒന്നിലധികം മൂല്യങ്ങൾ നൽകൽ തുടങ്ങിയ റഫറൻസും റഫർ ചെയ്‌ത വേരിയബിളും തമ്മിലുള്ള ബന്ധം മാറാൻ പാടില്ലാത്തപ്പോൾ ഇത് അവയെ സുരക്ഷിതവും ഉപയോഗിക്കാൻ എളുപ്പവുമാക്കുന്നു.

പോയിൻ്ററിൻ്റെയും റഫറൻസ് മോഡിഫിക്കേഷൻ്റെയും വിശദമായ പ്രവർത്തനക്ഷമത

രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് ഫംഗ്ഷനുകളിലേക്കുള്ള പോയിൻ്ററുകളും റഫറൻസുകളും കൈമാറുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു. ചടങ്ങ് ഒരു പോയിൻ്റർ ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് അതിൻ്റെ പാരാമീറ്ററായി എടുക്കുന്നു, ഇത് പോയിൻ്ററിലൂടെ പൂർണ്ണസംഖ്യയുടെ മൂല്യം പരിഷ്കരിക്കാൻ അനുവദിക്കുന്നു. പ്രധാന ചടങ്ങിൽ, എന്ന വിലാസത്തിൽ വിളിക്കുന്നു , അത് മാറുന്നു xൻ്റെ മൂല്യം. അതുപോലെ, പ്രവർത്തനം ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് ഒരു റഫറൻസ് എടുക്കുന്നു, ഇത് പൂർണ്ണസംഖ്യയുടെ മൂല്യം നേരിട്ട് പരിഷ്കരിക്കാൻ അനുവദിക്കുന്നു. പ്രധാന ഫംഗ്ഷൻ വിളിക്കുന്നു കൂടെ , അത് മാറുന്നു yൻ്റെ മൂല്യം.

ഫംഗ്‌ഷനുകളിൽ ഡാറ്റ കൈമാറുന്നതിനും പരിഷ്‌ക്കരിക്കുന്നതിനും പോയിൻ്ററുകളും റഫറൻസുകളും ഉപയോഗിക്കാവുന്ന വ്യത്യസ്‌ത വഴികൾ ഇത് കാണിക്കുന്നു. പോയിൻ്ററുകൾ ഉപയോഗിക്കുന്നത് റഫറൻസുകൾക്ക് സമാനമായി യഥാർത്ഥ വേരിയബിളിൻ്റെ മൂല്യം പരിഷ്കരിക്കാൻ ഫംഗ്ഷനുകളെ അനുവദിക്കുന്നു. എന്നിരുന്നാലും, വ്യത്യസ്‌ത വേരിയബിളുകളിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നത് അല്ലെങ്കിൽ റഫറൻസുകൾ ചെയ്യാത്ത അസാധുവാക്കൽ അസൈൻ ചെയ്യുന്നത് പോലുള്ള കൂടുതൽ വഴക്കം പോയിൻ്ററുകൾ നൽകുന്നു. C++ പ്രോഗ്രാമിംഗിൽ അറിവോടെയുള്ള തീരുമാനങ്ങൾ എടുക്കുന്നതിനും കാര്യക്ഷമവും സുരക്ഷിതവുമായ കോഡ് സമ്പ്രദായങ്ങൾ ഉറപ്പാക്കുന്നതിനും ഈ വ്യത്യാസങ്ങൾ മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്.

C++ ലെ പോയിൻ്ററുകളും റഫറൻസുകളും തമ്മിലുള്ള വ്യത്യാസങ്ങൾ പര്യവേക്ഷണം ചെയ്യുന്നു

C++ പ്രോഗ്രാമിംഗ് ഉദാഹരണം

#include <iostream>
using namespace std;
void pointerExample() {
    int a = 5;
    int* ptr = &a; // Pointer to a
    cout << "Pointer Example:" << endl;
    cout << "Value of a: " << a << endl;
    cout << "Pointer ptr points to: " << *ptr << endl;
    *ptr = 10; // Modify a through ptr
    cout << "New value of a: " << a << endl;
}
void referenceExample() {
    int b = 5;
    int& ref = b; // Reference to b
    cout << "Reference Example:" << endl;
    cout << "Value of b: " << b << endl;
    cout << "Reference ref refers to: " << ref << endl;
    ref = 10; // Modify b through ref
    cout << "New value of b: " << b << endl;
}
int main() {
    pointerExample();
    referenceExample();
    return 0;
}

C++ ലെ പോയിൻ്ററും റഫറൻസ് വേരിയബിളുകളും വിശകലനം ചെയ്യുന്നു

C++ കോഡ് പ്രദർശനം

#include <iostream>
using namespace std;
void modifyPointer(int* p) {
    *p = 20;
}
void modifyReference(int& r) {
    r = 20;
}
int main() {
    int x = 10;
    int y = 10;
    cout << "Initial x: " << x << endl;
    modifyPointer(&x); // Pass by pointer
    cout << "Modified x through pointer: " << x << endl;
    cout << "Initial y: " << y << endl;
    modifyReference(y); // Pass by reference
    cout << "Modified y through reference: " << y << endl;
    return 0;
}

പോയിൻ്ററുകളുടെയും റഫറൻസുകളുടെയും വിപുലമായ വശങ്ങൾ പര്യവേക്ഷണം ചെയ്യുന്നു

അവയുടെ അടിസ്ഥാന ഉപയോഗങ്ങൾക്ക് പുറമേ, കൂടുതൽ വിപുലമായ പ്രോഗ്രാമിംഗ് ആശയങ്ങളിൽ C++ ലെ പോയിൻ്ററുകളും റഫറൻസുകളും നിർണായക പങ്ക് വഹിക്കുന്നു. അത്തരത്തിലുള്ള ഒരു വശമാണ് പോയിൻ്റർ അരിത്മെറ്റിക് എന്ന ആശയം, ഇത് കാര്യക്ഷമമായ നാവിഗേഷനും അറേകളുടെ കൃത്രിമത്വവും അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു പോയിൻ്റർ വർദ്ധിപ്പിക്കുന്നത് അതിനെ ഒരു അറേയിലെ അടുത്ത ഘടകത്തിലേക്ക് നീക്കുന്നു. ഇഷ്‌ടാനുസൃത ഡാറ്റാ ഘടനകൾ നടപ്പിലാക്കുകയോ ഹാർഡ്‌വെയറുമായി ഇൻ്റർഫേസ് ചെയ്യുകയോ പോലുള്ള ലോ-ലെവൽ മെമ്മറി കൃത്രിമത്വം ഉൾപ്പെടുന്ന സാഹചര്യങ്ങളിൽ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

മറുവശത്ത്, ഓപ്പറേറ്റർ ഓവർലോഡിംഗിൽ റഫറൻസുകൾ വളരെയധികം ഉപയോഗിക്കുന്നു, ഇത് ഉപയോക്തൃ-നിർവചിച്ച തരങ്ങളിൽ ഓപ്പറേറ്റർമാർക്ക് ഇഷ്‌ടാനുസൃത സ്വഭാവം നിർവചിക്കാൻ പ്രാപ്‌തമാക്കുന്ന സവിശേഷതയാണ്. ഈ ഓവർലോഡ് ചെയ്ത ഓപ്പറേറ്റർമാരുടെ റഫറൻസായി ഒബ്‌ജക്റ്റുകൾ കൈമാറുന്നതിലൂടെ, C++ കാര്യക്ഷമമായ മെമ്മറി ഉപയോഗം ഉറപ്പാക്കുകയും ഒബ്‌ജക്‌റ്റുകൾ പകർത്തുന്നതിൻ്റെ ഓവർഹെഡ് ഒഴിവാക്കുകയും ചെയ്യുന്നു. കൂടാതെ, റഫറൻസുകൾ കോപ്പി കൺസ്‌ട്രക്‌ടർമാരുടെയും അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാരുടെയും നടപ്പാക്കലിന് അവിഭാജ്യമാണ്, ക്ലാസുകളിൽ റിസോഴ്‌സ് മാനേജ്‌മെൻ്റ് ശരിയായി കൈകാര്യം ചെയ്യുന്നത് ഉറപ്പാക്കുന്നു, പ്രത്യേകിച്ചും ഡൈനാമിക് മെമ്മറി അലോക്കേഷൻ കൈകാര്യം ചെയ്യുമ്പോൾ.

എന്താണ് ഒരു പോയിൻ്റർ വേരിയബിൾ?
മറ്റൊരു വേരിയബിളിൻ്റെ മെമ്മറി വിലാസം സംഭരിക്കുന്ന ഒരു വേരിയബിളാണ് പോയിൻ്റർ വേരിയബിൾ. ഇത് ചൂണ്ടിക്കാണിക്കുന്ന വേരിയബിളിൻ്റെ പരോക്ഷമായ പ്രവേശനവും പരിഷ്‌ക്കരണവും അനുവദിക്കുന്നു.
എന്താണ് ഒരു റഫറൻസ് വേരിയബിൾ?
ഒരു റഫറൻസ് വേരിയബിൾ മറ്റൊരു വേരിയബിളിൻ്റെ അപരനാമമാണ്. ഡിക്ലെയർ ചെയ്യുമ്പോൾ അത് ആരംഭിക്കേണ്ടതാണ്, മറ്റൊരു വേരിയബിളിലേക്ക് റഫർ ചെയ്യാൻ വീണ്ടും അസൈൻ ചെയ്യാൻ കഴിയില്ല.
ഒരു പോയിൻ്റർ അസാധുവാകുമോ?
അതെ, ഒരു സാധുവായ മെമ്മറി ലൊക്കേഷനിലേക്ക് പോയിൻ്റ് ചെയ്യുന്നില്ലെന്ന് സൂചിപ്പിക്കാൻ ഒരു പോയിൻ്ററിന് ഒരു നൾ മൂല്യം (C++11-ലും അതിനുശേഷമുള്ളവയിലും nullptr) നൽകാം.
ഒരു റഫറൻസ് അസാധുവാകുമോ?
ഇല്ല, ഒരു റഫറൻസ് സാധുവായ ഒരു വേരിയബിളിനെ സൂചിപ്പിക്കണം, അത് അസാധുവാകാൻ കഴിയില്ല.
ഒരു ഫംഗ്ഷനിലേക്ക് ഒരു പോയിൻ്റർ എങ്ങനെ കൈമാറും?
ഫംഗ്‌ഷൻ പാരാമീറ്ററിലെ പോയിൻ്റർ തരം വ്യക്തമാക്കിയും അഡ്രസ്-ഓഫ് ഓപ്പറേറ്റർ (&) ഉപയോഗിച്ച് വേരിയബിളിൻ്റെ വിലാസം നൽകിക്കൊണ്ട് നിങ്ങൾ ഒരു ഫംഗ്‌ഷനിലേക്ക് ഒരു പോയിൻ്റർ കൈമാറുന്നു.
ഒരു ഫംഗ്‌ഷനിലേക്ക് നിങ്ങൾ എങ്ങനെയാണ് ഒരു റഫറൻസ് കൈമാറുന്നത്?
ഫംഗ്‌ഷൻ പാരാമീറ്ററിലെ റഫറൻസ് തരം വ്യക്തമാക്കിയും ഓപ്പറേറ്ററുടെ വിലാസം ഉപയോഗിക്കാതെ തന്നെ വേരിയബിൾ നേരിട്ട് കൈമാറുന്നതിലൂടെയും നിങ്ങൾ ഒരു ഫംഗ്‌ഷനിലേക്ക് ഒരു റഫറൻസ് കൈമാറുന്നു.
എന്താണ് പോയിൻ്റർ ഗണിതശാസ്ത്രം?
പോയിൻ്റർ ഗണിതത്തിൽ പോയിൻ്ററുകളിലെ കൂട്ടിച്ചേർക്കലും കുറയ്ക്കലും പോലുള്ള പ്രവർത്തനങ്ങൾ ഉൾപ്പെടുന്നു, പോയിൻ്റർ മൂല്യം കൂട്ടുകയോ കുറയ്ക്കുകയോ ചെയ്തുകൊണ്ട് അറേ ഘടകങ്ങളിലൂടെ നാവിഗേഷൻ അനുവദിക്കുന്നു.
എന്താണ് ഓപ്പറേറ്റർ ഓവർലോഡിംഗ്?
ഓപ്പറേറ്റർ ഓവർലോഡിംഗ് ഉപയോക്തൃ-നിർവചിച്ച തരങ്ങളിൽ ഓപ്പറേറ്റർമാർക്കുള്ള ഇഷ്‌ടാനുസൃത സ്വഭാവം നിർവചിക്കാൻ അനുവദിക്കുന്നു. കാര്യക്ഷമമായ മെമ്മറി ഉപയോഗം ഉറപ്പാക്കാൻ ഓപ്പറേറ്റർ ഓവർലോഡിംഗിൽ റഫറൻസുകൾ പലപ്പോഴും ഉപയോഗിക്കാറുണ്ട്.
ഫംഗ്‌ഷൻ പാരാമീറ്ററുകളിലെ പോയിൻ്ററുകളും റഫറൻസുകളും തമ്മിലുള്ള വ്യത്യാസം എന്താണ്?
പോയിൻ്ററുകൾ അസാധുവാകുകയും ഫംഗ്ഷനിൽ വീണ്ടും അസൈൻ ചെയ്യുകയും ചെയ്യാം, ഇത് കൂടുതൽ വഴക്കം നൽകുന്നു. റഫറൻസുകൾ അസാധുവാകാൻ പാടില്ല, സുരക്ഷിതത്വവും ഉപയോഗ എളുപ്പവും വാഗ്ദാനം ചെയ്യുന്ന അവരുടെ ജീവിതകാലം മുഴുവൻ ഒരേ വേരിയബിളിനെ പരാമർശിക്കേണ്ടതാണ്.

പോയിൻ്ററുകളും റഫറൻസുകളും സി++ പ്രോഗ്രാമിംഗിലെ അവശ്യ ഉപകരണങ്ങളാണ്, ഓരോന്നും വ്യത്യസ്‌തമായ ഉദ്ദേശ്യങ്ങൾ നിറവേറ്റുന്നു. പോയിൻ്ററുകൾ മെമ്മറി വിലാസങ്ങൾക്കൊപ്പം വഴക്കം നൽകുകയും പോയിൻ്റർ ഗണിതശാസ്ത്രം അനുവദിക്കുകയും ചെയ്യുന്നു, ഇത് താഴ്ന്ന നിലയിലുള്ള പ്രോഗ്രാമിംഗ് ജോലികൾക്ക് അനുയോജ്യമാക്കുന്നു. റഫറൻസുകൾ സുരക്ഷിതവും കൂടുതൽ ലളിതവുമായ വാക്യഘടന നൽകുന്നു, ഫംഗ്ഷൻ പാരാമീറ്ററുകൾക്കും ഓപ്പറേറ്റർ ഓവർലോഡിംഗിനും അനുയോജ്യമാണ്. ഓരോന്നും എപ്പോൾ ഉപയോഗിക്കണമെന്ന് മനസിലാക്കുന്നത് കാര്യക്ഷമവും ഫലപ്രദവുമായ കോഡ് ഉറപ്പാക്കുന്നു, പ്രവർത്തനത്തെ സുഗമമായി സന്തുലിതമാക്കുന്നു.

സി++ ലെ പോയിൻ്റർ വേരിയബിളുകളും റഫറൻസ് വേരിയബിളുകളും താരതമ്യം ചെയ്യുന്നു

പോയിൻ്റർ, റഫറൻസ് ഉദാഹരണങ്ങളുടെ ആഴത്തിലുള്ള വിശകലനം

പോയിൻ്ററിൻ്റെയും റഫറൻസ് മോഡിഫിക്കേഷൻ്റെയും വിശദമായ പ്രവർത്തനക്ഷമത

C++ ലെ പോയിൻ്ററുകളും റഫറൻസുകളും തമ്മിലുള്ള വ്യത്യാസങ്ങൾ പര്യവേക്ഷണം ചെയ്യുന്നു

C++ ലെ പോയിൻ്ററും റഫറൻസ് വേരിയബിളുകളും വിശകലനം ചെയ്യുന്നു

പോയിൻ്ററുകളുടെയും റഫറൻസുകളുടെയും വിപുലമായ വശങ്ങൾ പര്യവേക്ഷണം ചെയ്യുന്നു