클래스 활용

09.클래스의활용.pdf

1. this 포인터
2. friend 선언
3. static 멤버
4. 임시 객체

멤버 함수를 외부에서 정의

• 내부 정의
  • 클래스 선언 내에 함수 정의 구현
• 외부 정의
  • 클래스 선언: 함수 프로토타입
  • 멤버 함수 정의: 클래스 선언 외부에서 정의

class CPoint {
	private:
		int x, y;
	
	public:
		// 생성자
		CPoint(int a, int b): x(a), y(b) {}
		// 소멸자
		~CPoint(){cout << "소멸자" << endl;}
}

CPoint::CPoint(int a, int b) : x(a), y(b){
}

CPoint::~CPoint(){
	cout << "소멸자" << endl;
}

void CPoint::Move(int a, int b){
	x += a;
	y += b;
}

클래스 외부 정의할 때는 함수명 앞에 클래스 명이 있어야된다.

this 포인터

• 나의 주소를 접근할 때 this
• 나의 주소를 리턴할 때 return this
• 나의 참조를 리턴할 때 return *this

#include <iostream>

using namespace std;

class MyClass {
    public:
        int value;
    
    MyClass(int v){
        value = v;
    }
    
    // 멤버 함수에서 this 포인터 사용
    void printAddress(){
        cout << this << endl;
    }
    
    // this 포인터를 사용하여 객체의 멤버에 접근
    void setValue(int newValue){
        this->value = newValue;
    }
    
    // this 포인터를 사용하여 객체 자신을 반환
    MyClass* getThis(){
        return this;
    }
};

int main() {
    
    // 생성자 초기 값
    MyClass obj(10);
    
    obj.setValue(10);
    
    // 현재 주소 값 출력
    obj.printAddress();
    
    // this 포인터를 사용하여 객체 자신 반환
    MyClass* ptr = obj.getThis();
    
    cout << "Address return by getThis(): " << ptr << endl;
    
    return 0;
}

friend 선언

• 특정 클래스 입장에서 다른 전역 함수나 클래스 또는 다른 클래스의 멤버 함수를 자신의 friend로 선언하는 것
• 다른 객체들이 자신의 객체에 수정권한을 부여하는 거라고 보면 된다.
• friend 선언의 종류
  • 전역 함수를 friend로 선언
  • 다른 클래스를 friend로 선언
  • 다른 클래스의 멤버 함수를 friend로 선언

class CPoint {
	private:
		int x;
		int y;
	
	public:
		CPoint(int a=0, int b=0) : x(a), y(b) {}
		void Print() { cout << x << " " << y << endl;}
		
		// Center함수를 friend로 선언함.
		friend CPoint Center(CPoint P1, CPoint P2);
}

// CPoint객체를 변경시키는 Center함수
CPoint Center(CPoint P1, CPoint P2){
	CPoint Po;
	
	// CPoint의 멤버변수를 변경가능하게 함.
	Po.x = (P1.x + P2.x)/2; 
	Po.y = (P1.y + P2.y)/2;
	
    // 변환된 객체를 리턴.
	return Po;
}

void main(void){

	// 객체 생성
	CPoint P1(1, 2);
	CPoint P2(3, 4);
	
	// Center함수로부터 받은 리턴 값을 P3에 반환
	CPoint P3 = Center(P1, P2);
	
	// 4/2 = 2
	// 6/2 = 3
	
	// P3 출력
	P3.print();
	
	// 출력 결과 >> 2 3
}

static 멤버 변수

• 클래스 당 단 하나만 생성
• 모든 객체가 공유
• 클래스 변수
• static 변수는 하나의 cpp파일에서만 공유되는 변수이다.
  extern변수랑은 다름!!! extern은 프로젝트 전체에서 쓰여질 변수이다.

예제 코드

#include <iostream>

class CPoint {
private:
    int x;
    int y;

public:
	// static 변수
    static int Count;
    // 생성자
    CPoint(int a, int b) : x(a), y(b) {} 
    
    int printCount(){
        return Count;
    }
};

// CPoint에 있는 Count변수를 0으로 초기화
int CPoint::Count = 0;

int main() {
    
    // 객체 생성
    CPoint P1(1, 2);
    CPoint P2(3, 4);
    
    // 객체 안에 있는 static변수를 변경 시켜줌.
    P1.Count = 1;
    P2.Count =2;
    CPoint::Count = 3;
    
    
    std::cout <<P2.printCount();
    // 출력결과 >> 3
    return 0;
}

임시객체

• 일시적인 필요에 의해 생성되는 객체
• 한 번 사용되고 나서는 버려짐.
• 이름이 없다.

void main(void){
	// 임시 객체
	CPoint(1, 2).print();
	
	// 임시객체가 아님
	CPoint P1 = CPoint(3,4);
	CPoint &P2 = CPoint(5, 6);
	
	CPoint P3;
	// 대입을 위해 사용된 후 사라짐. 임시객체.
	P3 = CPoint(7, 8);
}

임시객체의 장단점

장점:

1. 코드 간결성: 임시 객체를 사용하면 코드가 간결해지고 가독성이 높아질 수 있습니다. 특히 한 줄로 표현 가능한 간단한 연산이나 함수 호출 등을 수행할 때 유용하다
2. 효율성: 임시 객체를 사용하면 중간 결과를 저장할 필요 없이 바로 연산 결과를 사용할 수 있습니다. 이로 인해 메모리 사용량이 줄어들고 성능 향상을 기대할 수 있다.
3. 코드 최적화: 컴파일러가 임시 객체를 최적화하여 불필요한 복사나 생성을 줄여 성능을 개선할 수 있습니다.

단점:

1. 메모리 관리 어려움: 임시 객체는 일반적으로 스택이 아닌 힙 메모리에 할당됩니다. 따라서 많은 임시 객체를 생성하고 해제하는 경우 메모리 관리가 어려울 수 있다.
2. 오버헤드: 임시 객체를 생성하고 소멸하는 과정은 일정한 오버헤드를 발생시킬 수 있습니다. 특히 복잡한 객체나 연산의 경우 오버헤드가 커질 수 있다.
3. 가독성 감소: 코드가 너무 많은 임시 객체를 사용하면 가독성이 감소할 수 있습니다. 특히 코드가 복잡해지고 디버깅이 어려워질 수 있다.