수색…


통사론

  • Class라는 이름의 클래스를 가정합니다.

    • type * ptr = & Class :: member; // 정적 멤버 만 가리킨다.
    • Class :: * ptr = & Class :: member 형식; // 비 정적 클래스 멤버를 가리킨다.
  • 비 정적 클래스 멤버에 대한 포인터의 경우 다음 두 정의가 제공됩니다.

    • 클래스 인스턴스;
    • 클래스 * p = & 인스턴스;
  • 클래스 멤버 변수에 대한 포인터

    • ptr = & Class :: i; // 모든 클래스 내에서 변수 i를 가리 킵니다.
    • 인스턴스. * ptr = 1; // 인스턴스의 i에 액세스
    • p -> * ptr = 1; // p에 액세스
  • 클래스 멤버 함수에 대한 포인터

    • ptr = & Class :: F; // 모든 클래스 내에서 함수 'F'를 가리킨다.
    • (인스턴스. * ptr) (5); // 인스턴스의 F를 호출한다.
    • (p → ptr) (6); // p의 F를 호출한다.

정적 멤버 함수에 대한 포인터

static 멤버 함수는 scope를 제외하고는 일반적인 C / C ++ 함수와 같습니다.

  • class 내부에 있으므로 class 이름으로 장식 된 이름이 필요합니다.
  • public , protected 또는 private 액세스 가능성이 있습니다.

따라서 static 멤버 함수에 액세스하여 올바르게 꾸미면 class 외부의 일반 함수처럼 함수를 가리킬 수 있습니다.

typedef int Fn(int); // Fn is a type-of function that accepts an int and returns an int

// Note that MyFn() is of type 'Fn'
int MyFn(int i) { return 2*i; }

class Class {
public:
    // Note that Static() is of type 'Fn'
    static int Static(int i) { return 3*i; }
}; // Class

int main() {
    Fn *fn;    // fn is a pointer to a type-of Fn

    fn = &MyFn;          // Point to one function
    fn(3);               // Call it
    fn = &Class::Static; // Point to the other function
    fn(4);               // Call it
 } // main()

멤버 함수에 대한 포인터

클래스의 멤버 함수에 액세스하려면 인스턴스 자체 또는 포인터 또는 참조로 특정 인스턴스에 대한 "핸들"이 있어야합니다. 클래스 인스턴스가 주어지면, 올바른 구문을 얻은 경우 멤버에 대한 포인터를 사용하여 다양한 멤버를 가리킬 수 있습니다! 물론 포인터는 여러분이 가리키는 것과 같은 타입으로 선언되어야합니다 ...

typedef int Fn(int); // Fn is a type-of function that accepts an int and returns an int

class Class {
public:
    // Note that A() is of type 'Fn'
    int A(int a) { return 2*a; }
    // Note that B() is of type 'Fn'
    int B(int b) { return 3*b; }
}; // Class

int main() {
    Class c;          // Need a Class instance to play with
    Class *p = &c;    // Need a Class pointer to play with

    Fn Class::*fn;    // fn is a pointer to a type-of Fn within Class

    fn = &Class::A;   // fn now points to A within any Class
    (c.*fn)(5);       // Pass 5 to c's function A (via fn)
    fn = &Class::B;   // fn now points to B within any Class
    (p->*fn)(6);      // Pass 6 to c's (via p) function B (via fn)
} // main()

앞의 예에서 멤버 변수에 대한 포인터와 달리 클래스 인스턴스와 멤버 포인터 간의 연결은 괄호로 묶여 야합니다 .*->* 가 이상하지는 않은 것처럼 보입니다 .* 충분히!)

멤버 변수에 대한 포인터

class 의 멤버에 액세스하려면 인스턴스 자체 또는 포인터 또는 참조로 특정 인스턴스에 대한 "핸들"이 있어야합니다. class 인스턴스가 주어지면, 올바른 구문을 얻은 경우 멤버에 대한 포인터를 사용하여 다양한 멤버를 가리킬 수 있습니다! 물론 포인터는 여러분이 가리키는 것과 같은 타입으로 선언되어야합니다 ...

class Class {
public:
    int x, y, z;
    char m, n, o;
}; // Class

int x;  // Global variable

int main() {
    Class c;        // Need a Class instance to play with
    Class *p = &c;  // Need a Class pointer to play with

    int *p_i;       // Pointer to an int

    p_i = &x;       // Now pointing to x
    p_i = &c.x;     // Now pointing to c's x

    int Class::*p_C_i; // Pointer to an int within Class

    p_C_i = &Class::x; // Point to x within any Class
    int i = c.*p_C_i;  // Use p_c_i to fetch x from c's instance
    p_C_i = &Class::y; // Point to y within any Class
    i = c.*p_C_i;      // Use p_c_i to fetch y from c's instance

    p_C_i = &Class::m; // ERROR! m is a char, not an int!

    char Class::*p_C_c = &Class::m; // That's better...
} // main()

pointer-to-member 구문에는 몇 가지 구문 요소가 추가로 필요합니다.

  • 포인터의 타입을 정의하기 위해서는 클래스 내부에 있다는 사실뿐만 아니라 기본 타입을 언급해야합니다 : int Class::*ptr; .
  • 클래스 또는 참조가 있고이를 포인터로 멤버와 함께 사용하려는 경우 .* 연산자 ( . 연산자와 유사)를 사용해야합니다.
  • 클래스에 대한 포인터를 가지고 있고 포인터를 멤버로 사용하려면 ->* 연산자 ( -> 연산자와 비슷 함)를 사용해야합니다.

정적 멤버 변수에 대한 포인터

static 멤버 변수는 scope를 제외하고는 일반적인 C / C ++ 변수와 같습니다.

  • class 내부에 있으므로 class 이름으로 장식 된 이름이 필요합니다.
  • public , protected 또는 private 액세스 가능성이 있습니다.

따라서 static 멤버 변수에 액세스하여 올바르게 꾸미면 class 외부의 일반 변수처럼 변수를 가리킬 수 있습니다.

class Class {
public:
    static int i;
}; // Class

int Class::i = 1; // Define the value of i (and where it's stored!)

int j = 2;   // Just another global variable

int main() {
    int k = 3; // Local variable

    int *p;

    p = &k;   // Point to k
    *p = 2;   // Modify it
    p = &j;   // Point to j
    *p = 3;   // Modify it
    p = &Class::i; // Point to Class::i
    *p = 4;   // Modify it
} // main()


Modified text is an extract of the original Stack Overflow Documentation
아래 라이선스 CC BY-SA 3.0
와 제휴하지 않음 Stack Overflow