수색…
통사론
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()