C/C++에서 원시 포인터와 함수 포인터가 지원하는 연산은 무엇입니까?

Question

함수 포인터가 지원하는 모든 연산은 원시 포인터와 다릅니다. >, <, < => 사용하는 경우 원시 포인터가 연산자를 지원합니까?

Answer 1

을, 그들은 컴파일하지만, 그 결과는 주소 만이있는 용도로하는 일관성을 보장 동일한 완전한 객체의 객체 (클래스 또는 배열의 두 멤버의 주소를 비교할 수 있음)와 함수 또는 객체를 자체와 비교할 수 있습니다.

경우에도, 어떤 포인터 유형과 작동 등 std::less<>, std::greater<> 등을 사용하여 일관된 결과를 얻을 수의 결과 각각의 내장 연산자 지정되지 않은 :

그

void f() { } 
void g() { } 

int main() { 
    int a, b; 

    ///// not guaranteed to pass 
    assert((&a < &b) == (&a < &b)); 

    ///// guaranteed to pass 
    std::less<int*> lss1; 
    assert(lss1(&a, &b) == lss1(&a, &b)); 
    // note: we don't know whether lss1(&a, &b) is true or false. 
    //  But it's either always true or always false. 

    ////// guaranteed to pass 
    int c[2]; 
    assert((&c[0] < &c[1]) == (&c[0] < &c[1])); 
    // in addition, the smaller index compares less: 
    assert(&c[0] < &c[1]); 

    ///// not guaranteed to pass 
    assert((&f < &g) == (&f < &g)); 

    ///// guaranteed to pass 
    assert((&g < &g) == (&g < &g)); 
    // in addition, a function compares not less against itself. 
    assert(!(&g < &g)); 

    ///// guaranteed to pass 
    std::less<void(*)()> lss2; 
    assert(lss2(&f, &g) == lss2(&f, &g)); 
    // note: same, we don't know whether lss2(&f, &g) is true or false. 

    ///// guaranteed to pass 
    struct test { 
    int a; 
    // no "access:" thing may be between these! 
    int b; 

    int c[1]; 
    // likewise here 
    int d[1]; 

    test() { 
     assert((&a < &b) == (&a < &b)); 
     assert((&c[0] < &d[0]) == (&c[0] < &d[0])); 

     // in addition, the previous member compares less: 
     assert((&a < &b) && (&c[0] < &d[0])); 
    } 
    } t; 
} 

모든 컴파일한다 비록 컴파일러가 자유롭게 원하는 코드 스 니펫에 대해 경고 할지라도.

---

기능 유형은 더는 sizeof 값의 pointee 유형이 작동하지 않습니다의 sizeof의 관점에서 정의 된 작업이 포함되지 않은 이후 : 어떤 포인터 타입에

void(*p)() = ...; 
// all won't work, since `sizeof (void())` won't work. 
// GCC has an extension that treats it as 1 byte, though. 
p++; p--; p + n; p - n; 

단항 + 작품을, 그리고 그 값을 반환 할 것이고, 함수 포인터에 대해서는 특별한 것이 없다. 포인터는 통상 정수 값으로 표현된다

void (**pp)() = &p; 
// all do work, because `sizeof (void(*)())` is defined. 
pp++; pp--; pp + n; pp - n; 

Answer 2

# 1 : 함수 포인터를 호출 할 수 있습니다.

# 2 : 관계 연산자는 포인터 연산에서 사용할 수 있고 서로 주소를 비교할 수 있으므로 포인터에 대해 지원됩니다. 실제 예 : 배열 탐색

int data[5] = { 1, 2, 3, 4, 5 }; 

// Increment pointer until it reaches the end-address. 
for (int* i = data; i < data + 5; ++i) { 
    std::cout << *i << endl; 
} 

Answer 3

포인터가 동일한 할당을 가리키는 경우 포인터를 비교할 수 있습니다. 예를 들어 동일한 배열의 요소를 가리키는 두 개의 포인터가있는 경우 해당 포인터에 대해 비항 등 비교 연산자를 사용할 수 있습니다. 반면에 서로 다른 객체를 가리키는 포인터가 두 개있는 경우 비교는 "정의되지 않음"이지만 실제로는 대부분의 컴파일러가 주소를 비교할뿐입니다.

char *text[] = "hello"; 
const char *e_ptr = strchr(text, 'e'); 
const char *o_ptr = strchr(text, 'o'); 
if (e_ptr < o_ptr) { ... } // this is legal 
char *other_text[] = "goodbye"; 
const char *b_ptr = strchr(other_text, 'b'); 
if (b_ptr > o_ptr) { ... } // not strictly legal 

Answer 4

연산자 <>, < =,> = 두 개의 포인터를 비교 같은 동일한 메모리 할당 (의 일부인 포인터에 대해 지원되지만, 단지 두 개의 포인터가 비교되는 경우, 신뢰할 수있는 결과를 생성하도록 보장 배열 할당의 인덱스). 이것들은 할당의 상대 위치를 나타냅니다 (즉, < b 일 경우, a는 b보다 배열에서 더 낮은 인덱스를 가리 킵니다). 동일한 할당에없는 포인터의 경우 결과는 구현에 따라 정의되며 (일부 아키텍처에서는지도에 필요한 호환성보다 엄격하게 위반할 수 있습니다. 예를 들어, 64 비트 포인터는 < 또는> 단일 할당이 32 비트 포인터에 허용 된 크기를 초과 할 수없는 경우 32 비트). 이들은 연속적인 메모리 할당을 다루지 않기 때문에 실제로 함수 포인터의 컨텍스트에서는 의미가 없습니다.

기타 원시 포인터 연산 : == 포인터가 동일한 개체를 가리키는 경우 ==를 반환합니다. - 두 포인터 사이의 바이트 수를 생성합니다 (동일한 할당에만 좋다고 생각합니까?). +는 의미가 없으므로 컴파일하지 않습니다.

함수 포인터의 경우에는 *로 참조 해제 할 수 있습니다.

포인터 - 투 - 멤버 함수에 대해

,이 연산자는 -.> *와 * 모두 기능과 객체 포인터를 들어

Answer 5

:

+ p; // works. the result is the address stored in p. 

마지막 함수 포인터 포인터 더이상 함수 포인터되지 않는다. 다른 모든 숫자 유형에서도 허용되는 포인터로 모든 것을 처리 할 수 ​​있습니다. + - */< < >> ==! =^& | ! ~ %. 나는 아무것도 잊지 않았 으면 좋겠다.

함수 포인터는() 연산자로 호출 할 수있는 방식 만 다릅니다.