TechCodeview

포인터에 대해 덧셈, 뺄셈 등과 같은 산술 연산을 수행할 수 있습니다. 그러나 포인터에 주소가 포함되어 있다는 것을 알고 있으므로 포인터에 대해 수행된 산술 연산의 결과는 다른 피연산자가 정수 유형인 경우에도 포인터가 됩니다. 포인터에서 포인터 빼기에서 결과는 정수 값이 됩니다. C 언어의 포인터에서는 다음과 같은 산술 연산이 가능합니다.

• 증가
• 감소
• 덧셈
• 빼기
• 비교

C에서 포인터 증가

포인터를 1씩 증가시키면 포인터는 바로 다음 위치를 가리키기 시작합니다. 이는 포인터가 가리키는 데이터 유형의 크기에 따라 포인터의 값이 증가하므로 일반적인 산술과 다소 다릅니다.

푸시용 git 명령

배열의 모든 요소를 ​​계속 가리키는 포인터에 대한 증분 연산을 사용하여 배열을 탐색하고, 이에 대해 일부 작업을 수행하고, 루프에서 자신을 업데이트할 수 있습니다.

포인터를 증가시키는 규칙은 다음과 같습니다.

 new_address= current_address + i * size_of(data type) 

여기서 i는 포인터가 증가하는 숫자입니다.

32비트

32비트 int 변수의 경우 2바이트씩 증가합니다.

64비트

64비트 int 변수의 경우 4바이트씩 증가합니다.

64비트 아키텍처에서 포인터 변수를 증가시키는 예를 살펴보겠습니다.

 #include int main(){ int number=50; int *p;//pointer to int p=&number;//stores the address of number variable printf('Address of p variable is %u 
',p); p=p+1; printf('After increment: Address of p variable is %u 
',p); // in our case, p will get incremented by 4 bytes. return 0; } 

산출

 Address of p variable is 3214864300 After increment: Address of p variable is 3214864304 

포인터를 사용하여 배열 순회

 #include void main () { int arr[5] = {1, 2, 3, 4, 5}; int *p = arr; int i; printf('printing array elements...
&apos;); for(i = 0; i<5; i++) { printf('%d ',*(p+i)); } < pre> <p> <strong>Output</strong> </p> <pre> printing array elements... 1 2 3 4 5 </pre> <h2>Decrementing Pointer in C</h2> <p>Like increment, we can decrement a pointer variable. If we decrement a pointer, it will start pointing to the previous location. The formula of decrementing the pointer is given below:</p> <pre> new_address= current_address - i * size_of(data type) </pre> <h3>32-bit</h3> <p>For 32-bit int variable, it will be decremented by 2 bytes.</p> <h3>64-bit</h3> <p>For 64-bit int variable, it will be decremented by 4 bytes.</p> <p>Let&apos;s see the example of decrementing pointer variable on 64-bit OS.</p> <pre> #include void main(){ int number=50; int *p;//pointer to int p=&amp;number;//stores the address of number variable printf(&apos;Address of p variable is %u 
&apos;,p); p=p-1; printf(&apos;After decrement: Address of p variable is %u 
&apos;,p); // P will now point to the immidiate previous location. } </pre> <p> <strong>Output</strong> </p> <pre> Address of p variable is 3214864300 After decrement: Address of p variable is 3214864296 </pre> <h2>C Pointer Addition</h2> <p>We can add a value to the pointer variable. The formula of adding value to pointer is given below:</p> <pre> new_address= current_address + (number * size_of(data type)) </pre> <h3>32-bit</h3> <p>For 32-bit int variable, it will add 2 * number.</p> <h3>64-bit</h3> <p>For 64-bit int variable, it will add 4 * number.</p> <p>Let&apos;s see the example of adding value to pointer variable on 64-bit architecture.</p> <pre> #include int main(){ int number=50; int *p;//pointer to int p=&amp;number;//stores the address of number variable printf(&apos;Address of p variable is %u 
&apos;,p); p=p+3; //adding 3 to pointer variable printf(&apos;After adding 3: Address of p variable is %u 
&apos;,p); return 0; } </pre> <p> <strong>Output</strong> </p> <pre> Address of p variable is 3214864300 After adding 3: Address of p variable is 3214864312 </pre> <p>As you can see, the address of p is 3214864300. But after adding 3 with p variable, it is 3214864312, i.e., 4*3=12 increment. Since we are using 64-bit architecture, it increments 12. But if we were using 32-bit architecture, it was incrementing to 6 only, i.e., 2*3=6. As integer value occupies 2-byte memory in 32-bit OS.</p> <h2>C Pointer Subtraction</h2> <p>Like pointer addition, we can subtract a value from the pointer variable. Subtracting any number from a pointer will give an address. The formula of subtracting value from the pointer variable is given below:</p> <pre> new_address= current_address - (number * size_of(data type)) </pre> <h3>32-bit</h3> <p>For 32-bit int variable, it will subtract 2 * number.</p> <h3>64-bit</h3> <p>For 64-bit int variable, it will subtract 4 * number.</p> <p>Let&apos;s see the example of subtracting value from the pointer variable on 64-bit architecture.</p> <pre> #include int main(){ int number=50; int *p;//pointer to int p=&amp;number;//stores the address of number variable printf(&apos;Address of p variable is %u 
&apos;,p); p=p-3; //subtracting 3 from pointer variable printf(&apos;After subtracting 3: Address of p variable is %u 
&apos;,p); return 0; } </pre> <p> <strong>Output</strong> </p> <pre> Address of p variable is 3214864300 After subtracting 3: Address of p variable is 3214864288 </pre> <p>You can see after subtracting 3 from the pointer variable, it is 12 (4*3) less than the previous address value.</p> <p>However, instead of subtracting a number, we can also subtract an address from another address (pointer). This will result in a number. It will not be a simple arithmetic operation, but it will follow the following rule.</p> <p>If two pointers are of the same type,</p> <pre> Address2 - Address1 = (Subtraction of two addresses)/size of data type which pointer points </pre> <p>Consider the following example to subtract one pointer from an another.</p> <pre> #include void main () { int i = 100; int *p = &amp;i; int *temp; temp = p; p = p + 3; printf(&apos;Pointer Subtraction: %d - %d = %d&apos;,p, temp, p-temp); } </pre> <p> <strong>Output</strong> </p> <pre> Pointer Subtraction: 1030585080 - 1030585068 = 3 </pre> <h2>Illegal arithmetic with pointers</h2> <p>There are various operations which can not be performed on pointers. Since, pointer stores address hence we must ignore the operations which may lead to an illegal address, for example, addition, and multiplication. A list of such operations is given below.</p> <ul> <li>Address + Address = illegal</li> <li>Address * Address = illegal </li> <li>Address % Address = illegal</li> <li>Address / Address = illegal</li> <li>Address &amp; Address = illegal</li> <li>Address ^ Address = illegal</li> <li>Address | Address = illegal</li> <li> ~Address = illegal</li> </ul> <h2>Pointer to function in C</h2> <p>As we discussed in the previous chapter, a pointer can point to a function in C. However, the declaration of the pointer variable must be the same as the function. Consider the following example to make a pointer pointing to the function. <pre> #include int addition (); int main () { int result; int (*ptr)(); ptr = &amp;addition; result = (*ptr)(); printf(&apos;The sum is %d&apos;,result); } int addition() { int a, b; printf(&apos;Enter two numbers?&apos;); scanf(&apos;%d %d&apos;,&amp;a,&amp;b); return a+b; } </pre> </p><p> <strong>Output</strong> </p> <pre> Enter two numbers?10 15 The sum is 25 </pre> <h2>Pointer to Array of functions in C</h2> <p>To understand the concept of an array of functions, we must understand the array of function. Basically, an array of the function is an array which contains the addresses of functions. In other words, the pointer to an array of functions is a pointer pointing to an array which contains the pointers to the functions. Consider the following example.</p> <pre> #include int show(); int showadd(int); int (*arr[3])(); int (*(*ptr)[3])(); int main () { int result1; arr[0] = show; arr[1] = showadd; ptr = &amp;arr; result1 = (**ptr)(); printf(&apos;printing the value returned by show : %d&apos;,result1); (*(*ptr+1))(result1); } int show() { int a = 65; return a++; } int showadd(int b) { printf(&apos;
Adding 90 to the value returned by show: %d&apos;,b+90); } </pre> <p> <strong>Output</strong> </p> <pre> printing the value returned by show : 65 Adding 90 to the value returned by show: 155 </pre> <hr></5;>

C에서 포인터 감소

증가와 마찬가지로 포인터 변수를 감소시킬 수 있습니다. 포인터를 감소시키면 이전 위치를 가리키기 시작합니다. 포인터를 감소시키는 공식은 다음과 같습니다.

 new_address= current_address - i * size_of(data type) 

32비트

32비트 int 변수의 경우 2바이트씩 감소합니다.

64비트

64비트 int 변수의 경우 4바이트씩 감소됩니다.

로마 숫자 1부터 100까지

64비트 OS에서 포인터 변수를 감소시키는 예를 살펴보겠습니다.

 #include void main(){ int number=50; int *p;//pointer to int p=&number;//stores the address of number variable printf('Address of p variable is %u 
',p); p=p-1; printf('After decrement: Address of p variable is %u 
',p); // P will now point to the immidiate previous location. } 

산출

 Address of p variable is 3214864300 After decrement: Address of p variable is 3214864296 

C 포인터 추가

포인터 변수에 값을 추가할 수 있습니다. 포인터에 값을 추가하는 공식은 다음과 같습니다.

 new_address= current_address + (number * size_of(data type)) 

32비트

32비트 int 변수의 경우 2 * 숫자를 추가합니다.

64비트

64비트 int 변수의 경우 4 * 숫자를 추가합니다.

64비트 아키텍처에서 포인터 변수에 값을 추가하는 예를 살펴보겠습니다.

 #include int main(){ int number=50; int *p;//pointer to int p=&number;//stores the address of number variable printf('Address of p variable is %u 
',p); p=p+3; //adding 3 to pointer variable printf('After adding 3: Address of p variable is %u 
',p); return 0; } 

산출

 Address of p variable is 3214864300 After adding 3: Address of p variable is 3214864312 

보시다시피 p의 주소는 3214864300입니다. 그런데 p 변수에 3을 더하면 3214864312, 즉 4*3=12증분이 됩니다. 64비트 아키텍처를 사용하고 있으므로 12가 증가합니다. 그러나 32비트 아키텍처를 사용하는 경우 6으로만 증가합니다(예: 2*3=6). 32비트 OS에서는 정수 값이 2바이트 메모리를 차지합니다.

C 포인터 빼기

포인터 추가와 마찬가지로 포인터 변수에서 값을 뺄 수 있습니다. 포인터에서 숫자를 빼면 주소가 제공됩니다. 포인터 변수에서 값을 빼는 공식은 다음과 같습니다.

 new_address= current_address - (number * size_of(data type)) 

32비트

32비트 int 변수의 경우 2 * 숫자를 뺍니다.

64비트

64비트 int 변수의 경우 4 * 숫자를 뺍니다.

64비트 아키텍처에서 포인터 변수에서 값을 빼는 예를 살펴보겠습니다.

스윙이 있는 자바

 #include int main(){ int number=50; int *p;//pointer to int p=&number;//stores the address of number variable printf('Address of p variable is %u 
',p); p=p-3; //subtracting 3 from pointer variable printf('After subtracting 3: Address of p variable is %u 
',p); return 0; } 

산출

 Address of p variable is 3214864300 After subtracting 3: Address of p variable is 3214864288 

포인터 변수에서 3을 빼면 이전 주소 값보다 12(4*3) 적은 것을 알 수 있습니다.

그러나 숫자를 빼는 대신 다른 주소(포인터)에서 주소를 뺄 수도 있습니다. 결과적으로 숫자가 나타납니다. 단순한 산술연산은 아니지만 다음과 같은 규칙을 따릅니다.

두 포인터가 같은 유형인 경우

 Address2 - Address1 = (Subtraction of two addresses)/size of data type which pointer points 

하나의 포인터를 다른 포인터에서 빼려면 다음 예제를 고려하십시오.

 #include void main () { int i = 100; int *p = &i; int *temp; temp = p; p = p + 3; printf('Pointer Subtraction: %d - %d = %d',p, temp, p-temp); } 

산출

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

포인터를 사용한 잘못된 산술

포인터에 대해 수행할 수 없는 다양한 작업이 있습니다. 포인터는 주소를 저장하므로 덧셈, 곱셈과 같이 잘못된 주소로 이어질 수 있는 연산을 무시해야 합니다. 이러한 작업 목록은 다음과 같습니다.

링크드리스트 자바

• 주소 + 주소 = 불법
• 주소 * 주소 = 불법
• 주소 % 주소 = 불법
• 주소/주소 = 불법
• 주소 및 주소 = 불법
• 주소^ 주소 = 불법
• 주소 | 주소 = 불법
• ~주소 = 불법

C의 함수에 대한 포인터

이전 장에서 논의한 것처럼 포인터는 C에서 함수를 가리킬 수 있습니다. 그러나 포인터 변수의 선언은 함수와 동일해야 합니다. 함수를 가리키는 포인터를 만들려면 다음 예제를 고려하세요.

 #include int addition (); int main () { int result; int (*ptr)(); ptr = &addition; result = (*ptr)(); printf('The sum is %d',result); } int addition() { int a, b; printf('Enter two numbers?'); scanf('%d %d',&a,&b); return a+b; } 

산출

 Enter two numbers?10 15 The sum is 25 

C의 함수 배열에 대한 포인터

함수 배열의 개념을 이해하려면 함수 배열을 이해해야 합니다. 기본적으로 함수의 배열은 함수의 주소를 포함하는 배열입니다. 즉, 함수 배열에 대한 포인터는 함수에 대한 포인터를 포함하는 배열을 가리키는 포인터입니다. 다음 예를 고려하십시오.

 #include int show(); int showadd(int); int (*arr[3])(); int (*(*ptr)[3])(); int main () { int result1; arr[0] = show; arr[1] = showadd; ptr = &arr; result1 = (**ptr)(); printf('printing the value returned by show : %d',result1); (*(*ptr+1))(result1); } int show() { int a = 65; return a++; } int showadd(int b) { printf('
Adding 90 to the value returned by show: %d',b+90); } 

산출

 printing the value returned by show : 65 Adding 90 to the value returned by show: 155