c++멤버 함수 와 비 멤버 함수 선택

1.가능 한 한 클래스 의 비 멤버 함수 와 우 원 함수 로 클래스 의 멤버 함 수 를 교체 합 니 다.예 를 들 어 하나의 클래스 로 사람 피 플
 
1 class People{
2 public:
3 ...
4 void Getup( );
5 void Washing( );
6 void eating( );
7 ...
8 }
을 모 의 합 니 다.사실은 위의 세 가지 동작 은 아침 에'일어나','설 겆 이','밥 먹 기'세 가지 흔히 볼 수 있 는 동작 입 니 다.만약 에 지금 하나의 함수 로 구성원 함 수 를 사용 하면

1 class People
2 {
3 ...
4 void morningAction( )
5 {
6 Getup( );
7 Washing( );
8 eating( );
9 }
10 }
이 고 비 구성원 함 수 를 쓰 면
 
1 void moringAction(People& p)
2 {
3 p.Getup( );
4 p.Washing( );
5 p.eating( );
6 }
선택 클래스 의 구성원 함수 입 니까?아니면 클래스 의 비 구성원 함수 입 니까?대상 을 향 해 서 는 조작 데이터 의 함수 와 데 이 터 를 함께 놓 아야 한다.그렇다 고 멤버 함 수 를 선택 하 는 것 은 아니다.패 키 징 의 측면 에서 볼 때 멤버 함수 의 moringAction 패 키 징 성 은 비 멤버 함수 보다 낮다.만약 어떤 물건 이 봉인 된다 면,그것 은 더 이상 볼 수 없 을 것 이다.많은 물건 이 봉 인 될 수록 그것 을 볼 수 있 는 사람 은 적다.그래서 비 구성원 함수 의 종 류 를 사용 하여 포장 성 이 비교적 낮다.그러나 그것 을 보 는 사람 이 적 을 수록 우 리 는 그것 을 변화 시 킬 수 있다.왜냐하면 우리 의 변 화 는 변 화 를 보 는 사람들 에 게 만 직접적인 영향 을 주기 때문이다.그래서 봉 인 된 것 이 많 을 수록,어떤 것 을 바 꾸 는 능력 이 커진다.대상 내 데 이 터 를 고려 하고 있 습 니 다.코드 가 적 을 수록 데이터(접근)를 볼 수 있 고 데이터 가 많이 봉 인 될 수 있 으 며 대상 데 이 터 를 자 유 롭 게 바 꿀 수 있 습 니 다.현재 한 구성원 함수,비 구성원 함수 가 모두 같은 기능 을 제공 할 수 있다 면 우 리 는 비 구성원 함 수 를 선택 합 니 다.다음 내용 을 말 하기 전에 C++의 유형 변환 은 디 스 플레이 형식 변환 과 암시 적 형식 변환 에 대해 이야기 합 니 다.2.디 스 플레이 형식 변환 C++디 스 플레이 형식 변환 연산 자 는 각각 staticcast,const_cast,dynamic_cast 와 reinterpretcast 2.1static_캐 스 트 전환 기능 은 C 스타일 전환 과 마찬가지 로 의미 도 같다.static 사용 하기캐 스 트 는 상속 관계 가 없 는 유형 을 바 꿀 수 있다.단,내 장 된 형식 을 사용자 정의 형식 으로 바 꾸 거나 사용자 정의 형식 을 내 장 된 형식 으로 바 꿀 수 없 으 며,cosnt 형식 을 제거 할 수 는 없 지만,non-cosnt 형식 을 const 형식 으로 바 꿀 수 있 음 을 주의해 야 합 니 다.예 를 들 어 char a='a';int b=static_cast(a); 두 유형 간 의 전환 도 사실은 스스로 지원 을 실현 해 야 한다.원리 와 내장 유형 간 의 전환 이 비슷 하 다.4567913)운행 결 과 는 car'info:cost is 20.weight is 66 people'info:age is 1000.height is 2872.2constcast 는 주로 const 와 volatileness 속성 을 제거 하 는 데 사용 되 며,대부분의 경우 const 제한 을 제거 하 는 데 사 용 됩 니 다.2.3dynamic_캐 스 트 는 계승 관 계 를 따라 안전하게 유형 전환 을 하 는 데 사 용 됩 니 다.보통 dynamic 사용캐 스 트 는 기본 포인터 나 인용 을 파생 포인터 나 인용 으로 바 꾸 고 변환 에 실 패 했 을 때 빈 포인터 로 되 돌려 줍 니 다.2.4reinterprit_cast 이 변환 의 가장 일반적인 용 도 는 함수 포인터 형식 사이 에서 전환 하 는 것 입 니 다.
 
1 #include <iostream>
2 class Car;
3
4 class People
5 {
6 public:
7 People(int a,int h)
8 :age(a),height(h)
9 {}
10
11 inline int getAge() const
12 {
13 return age;
14 }
15
16 inline int getHeight() const
17 {
18 return height;
19 }
20
21 People & operator=(const Car& c);
22 private:
23 int age;
24 int height;
25 };
26
27 class Car
28 {
29 public:
30 Car(double c, double w)
31 :cost(c),weight(w)
32 {}
33
34 inline double getCost() const
35 {
36 return cost;
37 }
38
39 inline double getWeight() const
40 {
41 return weight;
42 }
43
44 Car & operator=(const People& c);
45 private:
46 double cost;
47 double weight;
48 };
49
50 People & People::operator=(const Car& c)
51 {
52 age = static_cast<int>(c.getCost());
53 height = static_cast<int>(c.getWeight());
54 return *this;
55 }
56
57 Car & Car::operator=(const People& c)
58 {
59 cost = static_cast<double>(c.getAge());
60 weight = static_cast<double>(c.getHeight());
61 return *this;
62 }
63
64 int main(int argc,char * argv[])
65 {
66 Car c(1000.87,287.65);
67 People p(20,66);
68 People p2(0,0);
69 Car c2(0.00,0.00);
70 p2=c;
71 c2=p;
72 std::cout<< "car'info: cost is " << c2.getCost() << ". weight is " << c2.getWeight() <<std::endl;
73 std::cout<< "people'info: age is " << p2.getAge() <<". height is " << p2.getHeight() <<std::endl;
74 return 0;
75 }
일반적으로 함수 포인터 유형 을 바 꾸 는 것 을 피해 야 한다.3.비 구성원 함 수 를 사용 하면 암시 적 변환 C++는 암시 적 형식 변환 을 지원 합 니 다.예 를 들 어 연산 을 할 때 나 매개 변 수 를 함수 에 전달 할 때 암시 적 형식 전환 이 자주 발생 합 니 다.유리 수 를 표현 하기 위해 클 라 스 를 설계 했다 고 가정 하 세 요.사실은 암시 적 유형 전환 을 지원 하 는 것 은 어 묵 의 결정 이다.물론 수치 유형 을 만 들 때 는 예외다.다음은 유리수 유형 을 정의 합 니 다.
 
1 typedef void (*fun) ( ) //
2 fun funArray[10]; // 10 。
3 int function( ); // int
4 funArray[0] = &function( ) // !
5 funArray[0] = reinterpret_cast<fun>(&function); //ok 。
유리수 유형 은 당연히 산수 연산 을 지원 하지만 구성원 함수 나 비 구성원 함수 또는 유원 함수 로 설명 할 지 는 확실 하지 않 습 니 다.우선 멤버 함수 표기 법 을 고려 하 는 것 이다.
 
1 class Rational {
2 public:
3 Rational( int numerator = 0,int denominator =1 );
4 int numerator( ) const;
5 int denominator ( ) const ;
6 private:
7 ...
8 }
그렇다면 왜 상수 를 앞 당 기 는 것 이 잘못된 것 일 까?여기 서 우 리 는 글 씨 를 바 꾸 었 습 니 다
 
1 class Rational {
2 public:
3 ...
4 const Rational operator* (const Rational& rhs) const;
5 ...
6 }
7 Rational testOne(1,4);
8 Rational testTwo(1,1);
9 //
10 Rational result = testOne * testTwo;
11 //
12 result = testOne * 2; //ok
13 //
14 result = 2 * testOne //error!!
.여기 서 무슨 일이 일 어 났 습 니까?사실 첫 줄 식 에서 이른바 암시 적 유형 전환 이 발생 했다.어디 에 암시 적 유형 전환 이 발생 했 습 니까?위의 코드 operator*함수 인 자 는 const Rational 형식 이 고 2 는 cosnt int 형식 입 니 다.컴 파일 러 는 non-explicit 형의 단일 매개 변수 류 가 int 형식의 구조 함수 로 Rational 형식 을 만 들 수 있 음 을 발견 했다.그래서 컴 파일 러 가 그렇게 해서 암시 적 형식 전환 이 발생 했다.그래서 첫 번 째 식 은 정상적으로 작 동 할 수 있 지만 두 번 째 는 Rational 형식 을 int 형식 으로 바 꾸 지 않 았 습 니 다.위의 두 식 이 정상적으로 운행 하도록 설계 해 야 합 리 적 인 운행 이 라 고 할 수 있다.4567913)위의 코드 에 따라 비 구성원 함수 로 설계 하면 int 유형 정 수 를 호출 할 때 암시 적 유형 전환 이 발생 합 니 다.operaotr*는 Rational class 의 우원 함수 라 고 불 러 야 합 니까?본 예 에 있어 서 는 전혀 필요 없다.만약 당신 이 어떤 함수 의 모든 매개 변 수 를 위해 유형 변환 을 해 야 한다 면,이 함 수 는 반드시 비 구성원 함수 여야 합 니 다.4.암시 적 유형 전환 을 신중하게 사용 하 는 것 은 언어 자체 의 특성 이기 때문에 우 리 는 일부 유형의 암시 적 전환 에 무력 하 다.그러나 사용자 정의 클래스 를 작성 할 때,우 리 는 함 수 를 제공 하여 컴 파 일 러 를 암시 적 형식 으로 변환 할 지 여 부 를 선택 할 수 있 습 니 다.컴 파일 러 가 암시 적 형식 으로 전환 할 수 있 는 두 가지 함수 가 있 습 니 다.단일 매개 변수 구조 함수 와 암시 적 형식 변환 연산 자 입 니 다.
 
1 result = testOne.operator*(2); //ok
2 result =2.operator*(oneHalf); //error
C++는 암시 적 형식 전환 을 지원 합 니 다.예 를 들 어 연산 을 할 때 나 매개 변 수 를 함수 에 전달 할 때 암시 적 형식 전환 이 자주 발생 합 니 다.컴 파일 러 가 암시 적 으로 전환 할 수 있 는 두 가지 함수 가 있다.단일 매개 변수 구조 함수 와 암시 적 형식 변환 연산 자.앞에서 암시 적 유형 전환 이 가 져 온 편리 한 점 을 말 했 는 지 귀 찮 은 점 을 말씀 드 리 겠 습 니 다.4567913)만약 에 여기 서 조심 하지 않 아 배열 a 의 아래 표 시 를 잊 어 버 리 면 여기 컴 파일 러 는 경고 메 시 지 를 보 내야 하지만 사실은 없다.컴 파일 러 는 a 를 Array형식 으로 보기 때문에 b 는 int 입 니 다.위의 경험 에 따 르 면 컴 파일 러 는 non-explicit 단일 매개 변수 구조 함수 의 매개 변수 유형 이 int 이 고 operator 는 Array형식 이 필요 합 니 다.그러면 컴 파일 러 는 이렇게 해서 암시 적 형식 전환 이 발생 했 습 니 다.만약 정말 이런 일이 발생 한다 면 매우 번 거 로 울 것 이 라 고 믿는다.어떻게 피 할 까요?구조 함 수 를 explicit 로 설명 합 니 다.암시 적 형식 전환 을 피하 다.

좋은 웹페이지 즐겨찾기