ಸಿ ++ ನಲ್ಲಿನ ಪಾಯಿಂಟರ್‌ಗಳು


ಸಿ ++ ನಲ್ಲಿನ ಪಾಯಿಂಟರ್‌ಗಳು




ಪಾಯಿಂಟರ್ಸ್

ನಿಮಗೆ ತಿಳಿದಿರುವಂತೆ ಪ್ರತಿಯೊಂದು ವೇರಿಯೇಬಲ್ ಕಂಪ್ಯೂಟರ್‌ನ ಮೆಮೊರಿಯ ಸ್ಥಳವಾಗಿದ್ದು, ಅಲ್ಲಿ ವೇರಿಯೇಬಲ್ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ. ನೀವು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಘೋಷಿಸಿದಾಗ, ಅದನ್ನು ಸಂಗ್ರಹಿಸಲು ಮೆಮೊರಿಯ ಒಂದು ಭಾಗವನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ. ಮೆಮೊರಿಯ ಈ ಭಾಗದ ಸ್ಥಳವನ್ನು ವೇರಿಯೇಬಲ್ ವಿಳಾಸದಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ. ಮೆಮೊರಿಯ ವಿಳಾಸವು ಸಂಖ್ಯಾ ಮೌಲ್ಯವಾಗಿದೆ. ವೇರಿಯೇಬಲ್ನ ಗುರುತಿಸುವಿಕೆಯನ್ನು (ಅದರ ಹೆಸರು) ಬಳಸಿಕೊಂಡು ಈ ವಿಳಾಸವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ವೇರಿಯೇಬಲ್ ಮುಂದೆ ವಿಳಾಸ-ಆಪರೇಟರ್ (&) ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಈ ವಿಳಾಸವನ್ನು ನೋಡಬಹುದು:

int a;
cout << "The address of \"a\" variable is " << &a;

ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗ ಇದು output ಟ್ಪುಟ್ ಆಗಿದೆ:

“A” ವೇರಿಯೇಬಲ್ನ ವಿಳಾಸ 0016FE18

ಈ ಕೋಡ್‌ನ output ಟ್‌ಪುಟ್ ವಿಭಿನ್ನ ಕಂಪ್ಯೂಟರ್‌ಗಳಲ್ಲಿ ವಿಭಿನ್ನವಾಗಿರುತ್ತದೆ.

ಪಾಯಿಂಟರ್ ಒಂದು ವೇರಿಯೇಬಲ್ ಆಗಿದೆ. ಇದರ 'ಮೌಲ್ಯವು ಮೆಮೊರಿಯಲ್ಲಿನ ಇತರ ವೇರಿಯೇಬಲ್ನ ವಿಳಾಸವಾಗಿದೆ. ಪಾಯಿಂಟರ್‌ನ ಘೋಷಣೆಯು ಘೋಷಣೆಯಲ್ಲಿ * ಬಳಕೆಯನ್ನು ಹೊರತುಪಡಿಸಿ ಸರಳ ವೇರಿಯೇಬಲ್ನ ಘೋಷಣೆಯಂತೆಯೇ ಇರುತ್ತದೆ:

data_type* identifier;

ವಿಭಿನ್ನ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಘೋಷಿಸುವ ಕೆಲವು ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:
//pointer to int
int* p;
//pointer to double
double* d;
//pointer to float
float* f;

ವಿಳಾಸ-ಆಫ್ (&) ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಪಾಯಿಂಟರ್‌ಗೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಬಹುದು:
int a;
cout << "The address of \"a\" variable is " << &a << endl;

//pointer to int
int* p;

p = &a;// now p is equal to the address of 'a' variable
cout << "The value of \"p\" variable is " << p;

ಪಾಯಿಂಟರ್ p ನ ಮೌಲ್ಯವು ಕಂಪ್ಯೂಟರ್ ಮೆಮೊರಿಯಲ್ಲಿ ವೇರಿಯಬಲ್ ಎ ವಿಳಾಸಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ:

“A” ವೇರಿಯೇಬಲ್ ವಿಳಾಸ 0028FBFC ಆಗಿದೆ
“P” ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯವು 0028FBFC ಆಗಿದೆ

ಇದನ್ನು ಈ ಕೆಳಗಿನ ಚಿತ್ರದಿಂದ ಪ್ರತಿನಿಧಿಸಬಹುದು:

ಪಾಯಿಂಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ನೀವು ಬಯಸಿದರೆ, ನೀವು ಪಾಯಿಂಟರ್ ಐಡೆಂಟಿಫೈಯರ್ ಮುಂದೆ ಏಕರೂಪದ ಡಿರೆಫರೆನ್ಸ್ ಆಪರೇಟರ್ (*) ಅನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಈ ಆಪರೇಟರ್ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ವಿಳಾಸದಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ:

int a = 10;
//pointer to int
int* p;
p = &a;// now p is equal to the address of 'a' variable
cout << "The value stored in memory location " << p << " is " << *p << endl;

Output ಟ್ಪುಟ್ ಹೀಗಿದೆ:

ಮೆಮೊರಿ ಸ್ಥಳ 001CFA10 ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ಮೌಲ್ಯವು 10 ಆಗಿದೆ

ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ ನೀವು ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಹಳಷ್ಟು ಕಾರಣಗಳಿಗಾಗಿ ಬಳಸಬಹುದು. ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಮಾಡಬಹುದಾದ ಕೆಲವು ಪ್ರಮುಖ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಇಲ್ಲಿ ನಾವು ಚರ್ಚಿಸುತ್ತೇವೆ:

ಮೆಮೊರಿಯ ಡೈನಾಮಿಕ್ ಹಂಚಿಕೆ

ಮೆಮೊರಿಯ ಹಸ್ತಚಾಲಿತ ನಿರ್ವಹಣೆಯನ್ನು ಸಿ ++ ಒದಗಿಸುತ್ತದೆ. ಇದರರ್ಥ ನೀವು ವೇರಿಯೇಬಲ್ಗಾಗಿ ಹಸ್ತಚಾಲಿತವಾಗಿ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಬಹುದು.

ಮೆಮೊರಿಯ ಕ್ರಿಯಾತ್ಮಕ ಹಂಚಿಕೆಯ ಅಗತ್ಯಕ್ಕೆ ಕಾರಣವಾಗುವ ಸರಳ ಕಾರ್ಯಗಳಲ್ಲಿ ಒಂದನ್ನು ಈ ಕೆಳಗಿನ ಸನ್ನಿವೇಶದಿಂದ ನಿರೂಪಿಸಬಹುದು:

“ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಲು ಬಳಕೆದಾರರನ್ನು ಕೇಳಿ.
ಬಳಕೆದಾರರಿಂದ ಇನ್ಪುಟ್ ತೆಗೆದುಕೊಳ್ಳಿ.
ನಮೂದಿಸಿದ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸಿ ”.

ಈ ಸಂದರ್ಭದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೊದಲು ಬಳಕೆದಾರರು ಎಷ್ಟು ಅಂಶಗಳನ್ನು ನಮೂದಿಸುತ್ತಾರೆ ಎಂಬುದನ್ನು ಪ್ರೋಗ್ರಾಂ "ತಿಳಿದಿಲ್ಲ". ಬಳಕೆದಾರರು ಸಂಖ್ಯೆಯ ಅಂಶಗಳ ಇನ್ಪುಟ್ ನಂತರ ರನ್ಟೈಮ್ ಸಮಯದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಇನ್ಪುಟ್ಗಾಗಿ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಬೇಕಾಗುತ್ತದೆ.

ಮೆಮೊರಿಯ ಕ್ರಿಯಾತ್ಮಕ ಹಂಚಿಕೆಗಾಗಿ ಸಿ ++ ಆಪರೇಟರ್ ಅನ್ನು ಹೊಸದಾಗಿ ನೀಡುತ್ತದೆ:

new data_type;

ನೀವು ರಚನೆಗಾಗಿ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಲು ಬಯಸಿದರೆ, ನೀವು ಈ ಕೆಳಗಿನ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ:
new data_type[size_of_array];

ಮೇಲೆ ವಿವರಿಸಿದ ಕಾರ್ಯದ ಪರಿಹಾರ ಇಲ್ಲಿದೆ:
int* arr;//pointer to int
int n;//number of elements
cout << "Please, enter the number of elements for input" << endl; cin >> n; // get n

arr = new int[n];//allocate memory for array of int of size n
//get user input
cout << "Enter " << n << " elements" << endl; //get elements in loop for (int i = 0; i != n; ++i) cin >> arr[i];
cout << "You entered :" << endl;
for (int i = 0; i != n; ++i)
	cout << "arr[" << i << "] = " << arr[i] << endl;

ಈ ಕೋಡ್ ಈ ಕೆಳಗಿನ output ಟ್‌ಪುಟ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ:

ದಯವಿಟ್ಟು, ಇನ್ಪುಟ್ಗಾಗಿ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ
5
5 ಅಂಶಗಳನ್ನು ನಮೂದಿಸಿ
1
2
3
4
0
ನೀವು ನಮೂದಿಸಿದ್ದೀರಿ:
arr [0] = 1
arr [1] = 2
arr [2] = 3
arr [3] = 4
arr [4] = 0

ಮೆಮೊರಿಯ ಕ್ರಿಯಾತ್ಮಕ ಹಂಚಿಕೆಯನ್ನು ನಂತರ “ಸಿ ++ ಡೈನಾಮಿಕ್ ಮೆಮೊರಿ” ವಿಷಯದಲ್ಲಿ ಚರ್ಚಿಸಲಾಗುವುದು.

ಹೊಸ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಕೈಯಾರೆ ಹಂಚಿಕೆ ಮಾಡಿದ್ದರೆ ಆಪರೇಟರ್ ಅಳಿಸುವಿಕೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಮೆಮೊರಿಯನ್ನು ಬಿಡುಗಡೆ ಮಾಡಬೇಕು:

delete pointer; ಒಂದೇ ವಸ್ತುವಿಗೆ ಮತ್ತು
delete[] pointer; ವಸ್ತುಗಳ ಒಂದು ಶ್ರೇಣಿಗಾಗಿ

ಪಾಯಿಂಟರ್ ಅಂಕಗಣಿತ

ಈ ಲೇಖನದಿಂದ ನೀವು ಈಗಾಗಲೇ ತಿಳಿದಿರುವಂತೆ, ಪಾಯಿಂಟರ್‌ಗಳು ಸಂಖ್ಯಾ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿವೆ. ಪಾಯಿಂಟರ್‌ಗಳೊಂದಿಗೆ ನೀವು ಈ ಕೆಳಗಿನ ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬಳಸಬಹುದು: ++, -, + ಮತ್ತು -.
ಇನ್ಕ್ರಿಮೆಂಟ್ ಆಪರೇಟರ್ (++) ಪಾಯಿಂಟರ್ ಪ್ರಕಾರಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಪಾಯಿಂಟರ್ ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಪಾಯಿಂಟರ್ ಪ್ರಕಾರದ ಗಾತ್ರದಿಂದ ವಿಳಾಸವನ್ನು ಹೆಚ್ಚಿಸಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಪಾಯಿಂಟರ್ ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ ಮತ್ತು ಪಾಯಿಂಟರ್ ಪ್ರಕಾರದ ಮುಂದಿನ ಅಂಶದ ವಿಳಾಸವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಾವು ಒಂದು ಪೂರ್ಣಾಂಕ ಶ್ರೇಣಿಗೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ:

int* a;
a = new int [3];

ಆರಂಭದಲ್ಲಿ ಈ ಪಾಯಿಂಟರ್ ಮೆಮೊರಿಯ ಪ್ರಾರಂಭ ವಿಳಾಸದ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ:

ನಾವು ಇದನ್ನು ಹೆಚ್ಚಿಸಿದರೆ:

++a;

ಇದು ಅದರ ಮೌಲ್ಯವನ್ನು ರಚನೆಯ ಮುಂದಿನ ಪೂರ್ಣಾಂಕಕ್ಕೆ ಬದಲಾಯಿಸುತ್ತದೆ:

ಇಳಿಕೆ ಆಪರೇಟರ್ (-) ಪಾಯಿಂಟರ್‌ನ ಮೌಲ್ಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಇದು ಪಾಯಿಂಟರ್ ಪ್ರಕಾರದ ಹಿಂದಿನ ಅಂಶದ ವಿಳಾಸವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ನಾವು ಮತ್ತೆ “ಎ” ಪಾಯಿಂಟರ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಿದರೆ:

--a;

ಇದು ಹಿಂದಿನ ಅಂಶದ ವಿಳಾಸವನ್ನು ಮತ್ತೆ ಸಂಗ್ರಹಿಸುತ್ತದೆ:

ನೀವು ಪಾಯಿಂಟರ್‌ನಿಂದ ಒಂದು ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸಬಹುದು ಅಥವಾ ಕಳೆಯಬಹುದು. ಪಾಯಿಂಟರ್‌ಗೆ N ಮೌಲ್ಯವನ್ನು ಸೇರಿಸುವುದರಿಂದ ಪಾಯಿಂಟರ್‌ನ ಪ್ರಕಾರದ ಮುಂದಿನ N ಅಂಶಗಳಿಗೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಫಾರ್ವರ್ಡ್ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಾವು ಪಾಯಿಂಟರ್‌ನ ಮೌಲ್ಯವನ್ನು 2 ರಿಂದ ಹೆಚ್ಚಿಸಬಹುದು:

a = a + 2;

ರಚನೆಯ 3 ನೇ ಅಂಶದ ವಿಳಾಸವನ್ನು ಸಂಗ್ರಹಿಸಲು ಇದು “a” ಪಾಯಿಂಟರ್ ಅನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ:

ಕಾರ್ಯದ ನಿಯತಾಂಕಗಳಾಗಿ ಪಾಯಿಂಟರ್‌ಗಳು

ನೀವು ಕಾರ್ಯಕ್ಕೆ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಹಾದುಹೋದಾಗ, ನೀವು ವೇರಿಯೇಬಲ್ ಮೌಲ್ಯವನ್ನು ರವಾನಿಸುತ್ತೀರಿ. ಆದರೆ ನೀವು ಕಾರ್ಯದಿಂದ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಆದರೆ ಕೆಲವೊಮ್ಮೆ ಕಾರ್ಯದಿಂದ ಅಸ್ಥಿರಗಳನ್ನು ಬದಲಾಯಿಸುವ ಸಾಧ್ಯತೆ ಬಹಳ ಉಪಯುಕ್ತವಾಗಿದೆ. ವೇರಿಯೇಬಲ್ ವಿಳಾಸವನ್ನು ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸುವ ಮೂಲಕ ನೀವು ಇದನ್ನು ಮಾಡಬಹುದು. ಇದರರ್ಥ ಕ್ರಿಯೆಯ ನಿಯತಾಂಕವು ಪಾಯಿಂಟರ್ ಆಗಿದೆ. ಮತ್ತು ಕಾರ್ಯವು ವೇರಿಯೇಬಲ್ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿರುವ ಮೆಮೊರಿಯ ಸ್ಥಳವನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ. ಈ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ:

void changeA(int* a)
{
	(*a) = 10;
}

ಕಾರ್ಯದಿಂದ ವೇರಿಯಬಲ್ ಅನ್ನು ಬದಲಾಯಿಸಲು ನಾವು ಪ್ರಯತ್ನಿಸಬಹುದು:

int *k= new int;
(*k) = 2;//setting value to k
cout << "k before calling function " << *k <<  endl;
changeA(k);
cout << "k after calling function " << *k << endl;

ಕೆ ವೇರಿಯಬಲ್ ಅನ್ನು ಕಾರ್ಯದಲ್ಲಿ ಬದಲಾಯಿಸಲಾಗಿದೆ:

ಕೆ 2 ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ಮೊದಲು
k ಕಾರ್ಯ 10 ಕ್ಕೆ ಕರೆ ಮಾಡಿದ ನಂತರ

ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಾದುಹೋಗುತ್ತದೆ

ಪಾಯಿಂಟರ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ನೀವು ಶ್ರೇಣಿಯನ್ನು ರವಾನಿಸಬಹುದು. ರಚನೆಯ ಹೆಸರು ರಚನೆಯ ಪ್ರಾರಂಭಕ್ಕೆ ಪಾಯಿಂಟರ್ ಆಗಿರುವುದರಿಂದ ಇದನ್ನು ಮಾಡಬಹುದು. ಆದ್ದರಿಂದ, ನೀವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಿದರೆ:

int myArr[5];

myArr ರಚನೆಯ ಪ್ರಾರಂಭಕ್ಕೆ ಪಾಯಿಂಟರ್ ಆಗಿದೆ.

ರಚನೆಯ ಅಂಶಗಳ ಮೊತ್ತವನ್ನು ಲೆಕ್ಕಹಾಕಲು ನಾವು ಒಂದು ಕಾರ್ಯವನ್ನು ರಚಿಸಬಹುದು. ಈ ಕಾರ್ಯವು 2 ನಿಯತಾಂಕಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ: ಪಾಯಿಂಟರ್ ಮತ್ತು ರಚನೆಯ ಗಾತ್ರ:

int sum(int* arr, int size)
{
	int sum = 0;
	for (int i = 0; i != size; ++i)
		sum += arr[i];
	return sum;
}

ಈಗ ನಾವು ಕಾರ್ಯ ಮುಖ್ಯದಲ್ಲಿ ಕೆಲವು ಮೌಲ್ಯಗಳೊಂದಿಗೆ ರಚನೆಯನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು:
for (int i = 0; i != 5; ++i)
	myArr[i] = i;

ಮತ್ತು ಇದರ ನಂತರ ನಾವು ರಚನೆಯ ಅಂಶಗಳ ಮೊತ್ತವನ್ನು ಲೆಕ್ಕಹಾಕಲು ಕಾರ್ಯವನ್ನು ಕರೆಯಬಹುದು:
cout << "Sum of myArr's elements is " << sum(myArr, 5);

ಇಲ್ಲಿ, “ಮೊತ್ತ (myArr, 5)” ಅರೇ myArr ಅನ್ನು ರಚನೆಯ ಮೊದಲ ಅಂಶಕ್ಕೆ ಪಾಯಿಂಟರ್ ಬಳಸಿ ಕಾರ್ಯ ಮೊತ್ತಕ್ಕೆ ರವಾನಿಸಲಾಗುತ್ತದೆ.

ಕಾರ್ಯದಿಂದ ಅರೇಗೆ ಪಾಯಿಂಟರ್ ಹಿಂತಿರುಗಿ

ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ ನೀವು ಕಾರ್ಯಕ್ಕೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಾದುಹೋಗುವ ರೀತಿಯಲ್ಲಿಯೇ ನೀವು ಕಾರ್ಯದಿಂದ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಿಂತಿರುಗಿಸಬಹುದು. ರಚನೆಯ ಅಂಶಗಳ ಪ್ರಕಾರದ ಪ್ರಕಾರಕ್ಕೆ ನೀವು ಪಾಯಿಂಟರ್‌ನಂತೆ ಕಾರ್ಯದ ರಿಟರ್ನ್ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು:

type* function_name(parameters list);

ಉದಾಹರಣೆಗೆ, ಇಂಟ್ ಅರೇನ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಎದುರಿಗೆ ಬದಲಾಯಿಸಲು ನಾವು ಬಯಸುತ್ತೇವೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಈ ಕೆಳಗಿನ ಕಾರ್ಯವನ್ನು ರಚಿಸಬಹುದು:
int* changeArray(int* arr, int size)
{
	//get copy of array's elements
	int* copy = new int[size];
	for (int i = 0; i != size; ++i)
		copy[i] = arr[i];
	//changing the elements sign
	for (int i = 0; i != size; ++i)
		copy[i] *= -1;
	//return array from function
	return copy;
}

ಈಗ ನಾವು ಈ ಕಾರ್ಯವನ್ನು ಈ ರೀತಿ ಕರೆಯಬಹುದು:
int* newArr;
//call function that returns an array of int
newArr = changeArray(myArr, 5);
cout << " newArr contains:" << endl;
for (int i = 0; i != 5; ++i)
	cout << "newArr[" << i << "] = "  << newArr[i] << endl;

ಈ ಕಾರ್ಯವು ಹೊಸ ಪೂರ್ಣಾಂಕಗಳ ಶ್ರೇಣಿಯನ್ನು ನೀಡುತ್ತದೆ:

newArr ಒಳಗೊಂಡಿದೆ:
newArr [0] = 0
newArr [1] = -1
newArr [2] = -2
newArr [3] = -3
newArr [4] = -4

ಹತ್ತಿರ, ದೂರದ ಮತ್ತು ಬೃಹತ್ ಪಾಯಿಂಟರ್‌ಗಳು

ಹತ್ತಿರದ, ದೂರದ ಮತ್ತು ಬೃಹತ್ ಪಾಯಿಂಟರ್‌ಗಳು ಪಾಯಿಂಟರ್‌ಗಳಾಗಿವೆ, ಅವುಗಳು ವಿಭಾಗೀಯ ಮೆಮೊರಿ ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ಎದುರಿಸಲು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಅವು 16 ಬಿಟ್ ಇಂಟೆಲ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗೆ ಸಂಬಂಧಿಸಿವೆ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಆಧುನಿಕ ಕಂಪ್ಯೂಟರ್‌ಗಳ ಬಹುಪಾಲು ಭಾಗಗಳೊಂದಿಗೆ ಬಳಸಲಾಗುವುದಿಲ್ಲ. 16 ಬಿಟ್‌ಗಳ ಕಂಪೈಲರ್‌ಗಳು (ಟರ್ಬೊ ಸಿ ++, ಬೊರ್ಲ್ಯಾಂಡ್ ಸಿ ++) ವಿಭಿನ್ನ ರೀತಿಯ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತವೆ: ಪಾಯಿಂಟರ್‌ಗಳ ಪ್ರಕಾರವು ಅದನ್ನು ಎತ್ತಿ ತೋರಿಸಬಹುದಾದ ಮೆಮೊರಿ ಸ್ಥಳದಿಂದ ಭಿನ್ನವಾಗಿರುತ್ತದೆ. ಸೆಗ್ಮೆಂಟ್ ರಿಜಿಸ್ಟರ್ ಮತ್ತು ಆಫ್‌ಸೆಟ್ ರಿಜಿಸ್ಟರ್ ಬಳಸಿ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಮೆಮೊರಿ ಸ್ಥಳವನ್ನು ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ. ಎರಡೂ ರೆಜಿಸ್ಟರ್‌ಗಳು 16 ಬಿಟ್‌ಗಳ ಗಾತ್ರವನ್ನು ಹೊಂದಿವೆ. ವಿಳಾಸವನ್ನು ಈ ಕೆಳಗಿನ ಸೂತ್ರದಿಂದ ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತಿದೆ:

ವಿಳಾಸ = ಸೆಗ್ಮೆಂಟ್ ರಿಜಿಸ್ಟರ್ << 4 + ಆಫ್‌ಸೆಟ್ ರಿಜಿಸ್ಟರ್

ಪಾಯಿಂಟರ್ ಹತ್ತಿರ ಕೇವಲ 16 ಬಿಟ್‌ಗಳ ಅಗಲವಿದೆ. ಇದು ಆಫ್‌ಸೆಟ್ ವಿಳಾಸವನ್ನು ಮಾತ್ರ ಹೊಂದಿದೆ. ಅದಕ್ಕಾಗಿಯೇ ಇದು ಪ್ರಸ್ತುತ ವಿಭಾಗದಲ್ಲಿ ಗರಿಷ್ಠ 0xFFFF ಆಫ್‌ಸೆಟ್‌ನೊಂದಿಗೆ ಮೆಮೊರಿಯನ್ನು ಮಾತ್ರ ಪ್ರವೇಶಿಸಬಹುದು.

ಫಾರ್ ಪಾಯಿಂಟರ್ 32 ಬಿಟ್‌ಗಳ ಅಗಲವಿದೆ. ಇದು ವಿಭಾಗ ವಿಳಾಸ (16 ಬಿಟ್‌ಗಳು) ಮತ್ತು ಆಫ್‌ಸೆಟ್ ವಿಳಾಸವನ್ನು (16 ಬಿಟ್‌ಗಳು) ಹೊಂದಿದೆ. ಫಾರ್ ಪಾಯಿಂಟರ್ ಈ ವಿಭಾಗದಲ್ಲಿ ಯಾವುದೇ ವಿಭಾಗ ಮತ್ತು ಯಾವುದೇ ಆಫ್‌ಸೆಟ್‌ಗೆ ಸೂಚಿಸಬಹುದು. MK_FP (ಸೆಗ್ಮೆಂಟ್, ಆಫ್‌ಸೆಟ್) ಮ್ಯಾಕ್ರೋ ಬಳಸಿ ನೀವು ದೂರದ ಪಾಯಿಂಟರ್ ರಚಿಸಬಹುದು:

int far * farIntptr = (int far * )MK_FP(0xA000, 0x1234);

0xA000 ವಿಭಾಗಕ್ಕಾಗಿ ದೂರದ ಪಾಯಿಂಟರ್ ಬಳಸಿ ನೀವು 0xA0000 ರಿಂದ 0xAFFFF ವರೆಗಿನ ವಿಳಾಸವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ನೀವು ಪಾಯಿಂಟರ್‌ನ ಆಫ್‌ಸೆಟ್ ಮೌಲ್ಯವನ್ನು 0xFFFF ಹೆಚ್ಚಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ ಅದನ್ನು ಶೂನ್ಯಕ್ಕೆ ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ.

ಬೃಹತ್ ಪಾಯಿಂಟರ್ 32 ಬಿಟ್‌ಗಳ ಅಗಲವಿದೆ. ದೂರದ ಪಾಯಿಂಟರ್‌ನಿಂದ ಮುಖ್ಯ ವ್ಯತ್ಯಾಸವೆಂದರೆ ನೀವು ಪಾಯಿಂಟರ್‌ನ ವಿಭಾಗದ ವಿಳಾಸವನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ನೀವು 0xAFFFF ವಿಳಾಸದೊಂದಿಗೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೆಚ್ಚಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ - ನೀವು ಅದರ ವಿಭಾಗದ ವಿಳಾಸವನ್ನು 0xB000 ಗೆ ಬದಲಾಯಿಸುತ್ತೀರಿ. MK_FP (ವಿಭಾಗ, ಆಫ್‌ಸೆಟ್) ಮ್ಯಾಕ್ರೋವನ್ನು ಬಳಸುವ ಮೂಲಕ ಬೃಹತ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ರಚಿಸಬಹುದು:

int huge * hugeIntPtr = (int huge * )MK_FP(0xA000, 0xFFF0);

ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಪಾಯಿಂಟರ್

ಕಾರ್ಯಗಳಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ಬಳಸಲು ಸಿ ++ ಸಾಧ್ಯತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಕಾರ್ಯಕ್ಕೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸಲು ಹಲವಾರು ಕಾರಣಗಳಿವೆ. ಅಲ್ಗಾರಿದಮ್ ಅಥವಾ ಕಾರ್ಯದ ಒಂದು ನಿರ್ದಿಷ್ಟ ಭಾಗವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಆಯ್ಕೆ ಮಾಡುವ ಸಾಧ್ಯತೆಯನ್ನು ನೀವು ಬಳಕೆದಾರರಿಗೆ ನೀಡಲು ಬಯಸಿದಾಗ ಒಂದು ಬಳಕೆಯಾಗಿದೆ. ಇದರರ್ಥ ನೀವು ಒಂದು ಕಾರ್ಯಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಮತ್ತೊಂದು ಕಾರ್ಯಕ್ಕೆ ನಿಯತಾಂಕವಾಗಿ ರವಾನಿಸಬಹುದು.

ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ. 2 ಪೂರ್ಣಾಂಕಗಳಿಂದ ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಠ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುವ 2 ಕಾರ್ಯಗಳನ್ನು ನೀವು ಹೊಂದಿದ್ದೀರಿ:

int min(int a, int b)
{
	if (a < b) return a; return b; } int max(int a, int b) { if (a > b)
		return a;
	return b;
}

ಈಗ ನೀವು ಒಂದು ಕಾರ್ಯಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಘೋಷಿಸಬಹುದು. ಅಂತಹ ಘೋಷಣೆಗೆ ಬಳಸುವ ಸಾಮಾನ್ಯ ಸಿಂಟ್ಯಾಕ್ಸ್:
functionReturnType (*pointerIdentifier) (listOfFunctionsParameters);

ಉದಾಹರಣೆಗೆ, ನಿಮಿಷ ಮತ್ತು ಗರಿಷ್ಠ ಕಾರ್ಯಗಳ ಪಾಯಿಂಟರ್ ಈ ಕೆಳಗಿನಂತೆ ಕಾಣುತ್ತದೆ:
int(*funPtr)(int, int);

ಈಗ ನಾವು ಒಂದು ಕಾರ್ಯಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಮತ್ತೊಂದು ಕಾರ್ಯದ ನಿಯತಾಂಕವಾಗಿ ಬಳಸಬಹುದು - getArrayExtremum. getArrayExtremum ಕಾರ್ಯವು ಒಂದು ಪೂರ್ಣಾಂಕ ಶ್ರೇಣಿಯ ಶ್ರೇಷ್ಠ ಅಥವಾ ಚಿಕ್ಕ ಅಂಶವನ್ನು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ:
int getArrayExtremum(int* arr, int size, int(*funPtr)(int, int))
{
	int extremum = arr[0];
	for (int i = 1; i != size; ++i)
		extremum = funPtr(extremum, arr[i]);
	return extremum;
}

ಈ ಕಾರ್ಯವು 3 ನಿಯತಾಂಕಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ - ಮೊದಲನೆಯದು ಒಂದು ಪೂರ್ಣಾಂಕ ಶ್ರೇಣಿಗೆ ಒಂದು ಪಾಯಿಂಟರ್, ಎರಡನೆಯದು ರಚನೆಯ ಗಾತ್ರ ಮತ್ತು ಕೊನೆಯದು ಒಂದು ಕಾರ್ಯಕ್ಕೆ ಪಾಯಿಂಟರ್ ಆಗಿದ್ದು ಅದು ತೀವ್ರತೆಯನ್ನು ಪಡೆಯುವ ಬಗ್ಗೆ ನಿರ್ಧಾರ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ಈಗ ನಾವು ಒಂದೇ ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ರಚನೆಯ ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಠ ಅಂಶವನ್ನು ಪಡೆಯಬಹುದು - getArrayExtremum:

//declare a pointer to function that takes 2 integers as a parameter and returns an integer
int(*funPtr)(int, int);

//declare and initialize an array of integers
int newArrOfInt[] = {-2, 4, 4, 0, -5, 8, 3,2};
funPtr = min; //now funPtr points up function min

//get minimum element of this array by using pointer to min function as the 3rd parameter
int minEl = getArrayExtremum(newArrOfInt, 8, funPtr);

cout << "The minimum of the array is " << minEl << endl;

funPtr = max; //now funPtr points up function max

//get maximum element of this array by using pointer to max function as the 3rd parameter
int maxEl = getArrayExtremum(newArrOfInt, 8, funPtr);

cout << "The maximum of the array is " << maxEl << endl;

const ಪಾಯಿಂಟರ್

ಪಾಯಿಂಟರ್‌ಗಳೊಂದಿಗೆ ಕಾನ್ಸ್ಟ್‌ ಕೀವರ್ಡ್‌ ಅನ್ನು ಬಳಸಲು 3 ಮಾರ್ಗಗಳಿವೆ:

ಸ್ಥಿರ ಡೇಟಾಗೆ ಪಾಯಿಂಟರ್

ಪಾಯಿಂಟರ್ ಬಳಸಿ ಡೇಟಾವನ್ನು ಮಾರ್ಪಡಿಸಲು ಅನುಮತಿಸದ ಸ್ಥಿರ ಡೇಟಾಗೆ ಪಾಯಿಂಟರ್. ಇದನ್ನು ಈ ಕೆಳಗಿನ ರೀತಿಯಲ್ಲಿ ಘೋಷಿಸಬಹುದು:

const type* ptr

or
type const* ptr;

ಉದಾಹರಣೆ:
const int*  constData;

ಸ್ಥಿರ ವಿಳಾಸದೊಂದಿಗೆ ಪಾಯಿಂಟರ್

ಸ್ಥಿರ ವಿಳಾಸವನ್ನು ಹೊಂದಿರುವ ಪಾಯಿಂಟರ್ ಅನ್ನು ಈ ಕೆಳಗಿನ ರೀತಿಯಲ್ಲಿ ಘೋಷಿಸಬಹುದು:

type * const ptr = memoryAddress;

ಉದಾಹರಣೆ:
int t = 7;
int* const constAddres = &t;

ಸ್ಥಿರ ಡೇಟಾ ಮತ್ತು ಸ್ಥಿರ ವಿಳಾಸದೊಂದಿಗೆ ಪಾಯಿಂಟರ್

ಸ್ಥಿರ ಡೇಟಾ ಮತ್ತು ಸ್ಥಿರ ವಿಳಾಸವನ್ನು ಹೊಂದಿರುವ ಪಾಯಿಂಟರ್ ಅನ್ನು ಈ ಕೆಳಗಿನ ರೀತಿಯಲ್ಲಿ ಘೋಷಿಸಬಹುದು:

const type * const constDataConstAddress = memoryAddress;

or

type const * const constDataConstAddress = memoryAddress

ಡಬಲ್ ಮತ್ತು ಟ್ರಿಪಲ್ ಪಾಯಿಂಟರ್. ಬಹು ಇಂಡೈರೆಕ್ಷನ್

ಡಬಲ್ ಮತ್ತು ಟ್ರಿಪಲ್ ಪಾಯಿಂಟರ್ ಒಂದು ರೀತಿಯ ಬಹು ಇಂಡೈರೆಕ್ಷನ್ ಆಗಿದೆ. ಡಬಲ್ ಪಾಯಿಂಟರ್ ಎನ್ನುವುದು ಪಾಯಿಂಟರ್‌ಗೆ ಪಾಯಿಂಟರ್ ಆಗಿದೆ. ಇದರರ್ಥ ಈ ಪಾಯಿಂಟರ್ ಮತ್ತೊಂದು ಪಾಯಿಂಟರ್‌ನ ವಿಳಾಸವನ್ನು ವೇರಿಯೇಬಲ್‌ಗೆ ಸೂಚಿಸುತ್ತದೆ. ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ:

int a = 10;
cout << "The address of \"a\" variable is " << &a << endl;

//pointer to int
int* p;
	
p = &a;// now p is equal to the address of 'a' variable
cout << "The value of \"p\" variable is " << p << endl;
//pointer to pointer
int** doublePtr = &p;
cout << "The value of \"doublePtr\" variable is " << doublePtr << endl;

ಇದನ್ನು ಈ ಕೆಳಗಿನ ಚಿತ್ರದಿಂದ ಪ್ರತಿನಿಧಿಸಬಹುದು:

ಡಬಲ್ ಪಾಯಿಂಟರ್‌ನಿಂದ ಉಲ್ಲೇಖಿಸಲಾದ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ನೀವು ಬಯಸಿದರೆ ನೀವು ಎರಡು ಬಾರಿ ಡಿಫರೆನ್ಸ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ:

cout << "Value for **doublePtr " << ** doublePtr;

ಡಬಲ್ ಮತ್ತು ಟ್ರಿಪಲ್ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಹೆಚ್ಚಾಗಿ 2 ಕಾರಣಗಳಿಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ - ಒಂದು ಪಾಯಿಂಟರ್ ಅನ್ನು ಒಂದು ಕಾರ್ಯಕ್ಕೆ ಹಾದುಹೋಗುವುದು ಮತ್ತು 2 ಡಿ ಮತ್ತು 3 ಡಿ ಅರೇಗಳಿಗೆ ಮೆಮೊರಿಯ ಕ್ರಿಯಾತ್ಮಕ ಹಂಚಿಕೆ. ಡೈನಾಮಿಕ್ ಮೆಮೊರಿ ಹಂಚಿಕೆಗಾಗಿ ಪಾಯಿಂಟರ್‌ಗಳ ಬಳಕೆಯನ್ನು ಸಿ ++ ಡೈನಾಮಿಕ್ ಮೆಮೊರಿಯಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ.

ಕಾರ್ಯಗಳೊಂದಿಗೆ ಡಬಲ್ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಹೇಗೆ ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ನಾವು ಈ ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ಪರಿಶೀಲಿಸಬಹುದು: ಅದರೊಳಗೆ ಪಾಯಿಂಟರ್‌ನೊಂದಿಗೆ ನೀವು ಕಾರ್ಯವನ್ನು ಹೊಂದಿದ್ದೀರಿ:

void function1()
{
	int *p = new int; // a pointer to int
	(*p) = 10;
	//pass pointer p by reference to function2
	function2(&p); 
}

ಮತ್ತು ಫಂಕ್ಷನ್ 1 ರಲ್ಲಿ ನೀವು ಪಾಯಿಂಟರ್ “ಪಿ” ಅನ್ನು ಮತ್ತೊಂದು ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸಲು ಬಯಸುತ್ತೀರಿ - ಫಂಕ್ಷನ್ 2 ಉಲ್ಲೇಖದಿಂದ:
function2(&p);

ಈ ಸಂದರ್ಭದಲ್ಲಿ ಫಂಕ್ಷನ್ 2 ರ ನಿಯತಾಂಕವು ಪಾಯಿಂಟರ್‌ಗೆ ಪಾಯಿಂಟರ್ ಆಗಿರಬೇಕು:
void function2(int** p2)
{
	(**p2)+= 10;
}