friend

-> private의 접근 권한을 타 클래스에게 허용하는 문법

-> 은닉화를 위반하는 문법이라 잘 사용하지않음.

 

friend를 사용하여 다른 클래스 호출

#include "Girl.h"
class CBoy
{
public:
	CBoy();
	CBoy(int _a, int _b);
	~CBoy();

public:
	void Func();
	void Girl_Func(CGirl* _girl);

private:
	int		m_iA;
	int		m_iB;


	friend class CGirl;	
};

friend를 사용하여 다른 클래스 안에 있는 함수 호출

#include "Girl.h"
class CBoy
{
public:
	CBoy();
	CBoy(int _a, int _b);
	~CBoy();

public:
	void Func();
	void Girl_Func(CGirl* _girl);

private:
	int		m_iA;
	int		m_iB;

	
	friend void CGirl::Boy_Func(CBoy* _boy);
};

 

friend 함수에서 호출된 클래스에서 호출한 클래스의 멤버 변수 및 함수에 접근이 가능하게된다.

CGirl : 호출된 클래스

CBoy : 호출한 클래스

 

'Programming > C++ Basic' 카테고리의 다른 글

C++ 객체 포인터  (0) 2020.09.17
C++ 상속성  (0) 2020.09.17
C++ this 포인터, extern 키워드  (0) 2020.09.16
C++ 복사 생성자(얕은 복사, 깊은 복사)  (0) 2020.09.16
C++ static과 클래스 , 멤버 함수  (0) 2020.09.15

this 포인터

-> this가 사용된 객체의 주소를 저장하고 있다.

-> 다음과 같이 CObj의 객체를 통해서 확인을 해보면 주소가 같은 것을 확인할 수가 있다.

class CObj
{
public:
	void Func()
	{
		cout << "this: " << this << endl;
	}
};

void main()
{	
	CObj	obj1;
	CObj	obj2;

	cout << "&obj1: " << &obj1 << endl;
	obj1.Func();
	cout << "----------------------------------" << endl;
	cout << "&obj2: " << &obj2 << endl;
	obj2.Func();
}

this 포인터의 사용

 

class CObj
{
public:
	CObj() : m_pBuff(nullptr) {}
	CObj(char* _pBuff)
	{
		this->m_pBuff = new char[strlen(_pBuff) + 1];
		strcpy_s(this->m_pBuff, strlen(_pBuff) + 1, _pBuff);
	}
	~CObj()
	{
		if (this->m_pBuff)
		{
			delete[] this->m_pBuff;
			this->m_pBuff = nullptr;
		}
		cout << "소멸자 호출" << endl;
	}
}

 

 

extern 키워드

-> 외부파일(.cpp 또는 .h) 어딘가에 전역 변수가 존재한다고 알려주는 역할을 한다.

#include "stdafx.h"

extern int a;

void main()
{
	cout << a << endl;
}

-> extern 키워드는 보통 찾아내기 쉽게 헤더 파일을 따로 만들어서 명시해놓는다고 한다.

#pragma once
#ifndef __EXTERN_H__
#define __EXTERN_H__

extern int a;

endif//!__EXTERN_H__

extern 키워드를 사용할 때는 아무 cpp 파일에 해당 자료형과 변수의 이름을 똑같이 전역 변수로 선언을 해야한다.

그렇지 않으면 링커 오류가 발생한다.

'Programming > C++ Basic' 카테고리의 다른 글

C++ 상속성  (0) 2020.09.17
C++ friend  (0) 2020.09.17
C++ 복사 생성자(얕은 복사, 깊은 복사)  (0) 2020.09.16
C++ static과 클래스 , 멤버 함수  (0) 2020.09.15
C++ const 와 클래스, 멤버 함수  (0) 2020.09.15

복사 생성자

-> 생성자 : 객체 생성 시 객체를 받아온다.

-> 인자로 넘어오는 객체의 멤버 값을 복사 받는 것.

 

디폴트 복사 생성자

-> 사용자가 복사 생성자를 정의하지 않으면 컴파일러가 복사 생성자를 생성하여 호출한다.

-> 사용자가 복사 생성자를 정의하면 컴파일러는 복사 생성자를 생성하지 않는다.

 

 

 

복사 생성자의 호출 시점 3가지

#1. 먼저 생성한 객체를 나중에 생성하는 객체의 인자로 전달하는 경우

#2. 함수의 인자로 객체가 전달되는 경우

#3. 함수의 반환 값으로 객체가 반환되는 경우

 

 

복사 생성자의 인자로 레퍼런스 타입을 받는 이유

-> 생성자는 함수의 일종이므로 호출하면 stack 영역이 할당된다.

-> 생성자의 stack 영역에 지역 변수를 할당하고 인자로 넘겨주는 값을 복사 받을 때

-> 또 다시 복사 생성자를 호출해야 하는 문제가 발생한다.

-> 즉, 무한루프가 걸린다.

 

 

레퍼런스가 아닌 포인터로 받으면 어떻게 될까?

-> 다음과 같이 포인터 연산으로 인해서 문제(주소 값 변경)가 발생할 수도 있기 때문에 포인터로 받지 않는다.

int a = 10;
int* ptr = &a;
int* ptr2 = ptr;

ptr2 = ptr + 1;

 

디폴트 복사 생성자의 문제점

-> 얕은 복사의 사용

-> 얕은 복사는 단순 대입으로 인한 복사이다.

 

얕은복사

-> 얕은 복사는 객체가 가진 멤버들의 값을 새로운 객체로 복사하는데 만약 객체가 참조타입의 멤버를 가지고 있다면 참조값만 복사가 된다.

class CObj
{
public:
	CObj() : m_pBuff(nullptr) {}
	CObj(char* _pBuff)
	{
		m_pBuff = new char[strlen(_pBuff) + 1];
		strcpy_s(m_pBuff, strlen(_pBuff) + 1, _pBuff);
	}
	~CObj()
	{
		if (m_pBuff)
		{
			delete[] m_pBuff;
			m_pBuff = nullptr;
		}
		cout << "소멸자 호출" << endl;
	}


	얕은 복사 방식의 구현
	CObj(CObj& _obj)
	{
		// 얕은 복사
		m_pBuff = _obj.m_pBuff;	
	}

private:
	char*		m_pBuff;
};

void main()
{	
	CObj	obj1("Hello");
	CObj	obj2(obj1);
}

-> main 함수를 시작하면서 obj1 객체를 만든다.

-> 이후, obj2 객체를 만드는데 디폴트 복사 생성자를 호출하여 만든다.

-> 함수가 종료되면서 stack 영역을 정리할 때 문제가 발생한다.

-> obj2 객체가 소멸하면서 obj2.m_pBuff가 가지고 있는 Heap 영역의 주소를 해제하려 했더니

-> obj2가 해제하면서 이미 할당되지 않은 공간이 되었다.

-> obj2는 obj1의 주소를 참조하고 있는 상태에서 해당 주소를 할당 해제 하였기 때문이다.

 

이러한 문제를 해결하는 방법은 '깊은 복사'를 사용하는 것이다.

 

깊은 복사

-> 얕은 복사와는 달리 객체가 가진 모든 멤버(값과 참조형식 모두)를 복사한다..

객체가 참조 타입의 멤버를 포함할 경우 참조값의 복사가 아닌 참조된 객체 자체가 복사되는 것을 깊은 복사라 한다.

 

-> 복사 받을 때 객체 또한 동적할당을 진행한다.

-> 각 객체들이 서로 다른 공간을 참조하게 만든다.

class CObj
{
public:
	CObj() : m_pBuff(nullptr) {}
	CObj(char* _pBuff)
	{
		m_pBuff = new char[strlen(_pBuff) + 1];
		strcpy_s(m_pBuff, strlen(_pBuff) + 1, _pBuff);
	}
	~CObj()
	{
		if(m_pBuff)
		{
			delete[] m_pBuff;
			m_pBuff = nullptr;
			cout << "소멸자 호출" << endl;
		}
	}

	CObj(CObj& _obj)
	{
		// 깊은 복사 방식의 구현
		this->m_pBuff = new char[strlen(_obj.m_pBuff) + 1];
		strcpy_s(m_pBuff, strlen(_obj.m_pBuff) + 1, _obj.m_pBuff);
	}
private:
	char* m_pBuff;
};

void main()
{	
	CObj	obj1("Hello");
	CObj	obj2(obj1);
}

-> main 함수를 시작하면서 obj1 객체를 만든다.

-> 이후, obj2 객체를 만드는데 디폴트 복사 생성자를 호출하여 만든다.

-> 함수가 종료되면서 stack 영역을 정리한다.

-> obj2 객체가 소멸하면서 obj2.m_pBuff가 가지고 있는 Heap 영역의 주소를 해제한다.

-> 복사 생성자에서 m_pBuff를 함수의 인자(객체)를 전달하여 새로 할당한다.

 

'Programming > C++ Basic' 카테고리의 다른 글

C++ friend  (0) 2020.09.17
C++ this 포인터, extern 키워드  (0) 2020.09.16
C++ static과 클래스 , 멤버 함수  (0) 2020.09.15
C++ const 와 클래스, 멤버 함수  (0) 2020.09.15
C++ 파일 입출력(fopen_s, fread(), fwrite())  (0) 2020.09.13

static과 클래스

-> static 변수의 초기화는 전역에서 진행한다.

 

static 변수는 Data 영역에 등록이 된다.

-> 프로그램 시작 시 메모리에 등록된다.

-> 사용자가 객체를 몇개 만들지 알 수 없는 상황이기 때문에

-> 컴파일러가 static 변수를 여러개 만들 수 없다.

-> 그래서, 단 하나만 메모리에 등록시킨 후 해당 클래스로 만든 모든 객체가 static 변수를 공유한다.

 

static 변수의 초기화

class CObj
{
public:
	CObj() {}
	CObj(int _a) : m_a(_a) // 불가능
	{
	}

private:
	static int m_a;

};

static 변수는 이니셜라이즈를 통해 초기화가 불가능하다.

왜냐하면 static 변수는 프로그램 시작 시 Data영역에 메모리 할당이 되고,

생성자의 호출 시점은 런타임 중 객체를 만드는 시점에 메모리에 등록이 되기 때문이다.

 

static 변수의 초기화 방법은 다음과 같다.

class CObj
{
public:
	CObj() {}
	CObj()
	{
	}

private:
	static int m_a;
};

int CObj::m_a = 10; // static 변수의 초기화

static 변수는 전역 변수로 초기화를 진행한다.

 

static 멤버 함수

-> static 멤버 함수/변수는 객체를 생성하지 않아도 접근 지정자가 public이면

static 멤버 함수/변수의 접근이 가능하고, 일반 함수/멤버 변수의 접근이 불가능하다.

 

-> 단, 일반 멤버 함수 내부에서는 static 멤버 함수/변수 접근이 가능하다.

class CObj
{
public:
	CObj() {}

	static void Static_Func()
	{
		// 멤버 함수
		Static_Func();  // 가능
		Func();         // 불가능

		// 멤버 변수
		m_StaticA = 10; // 가능
		m_a = 10;       // 불가능
	}

	void Func()
	{
		// 멤버 함수
		Static_Func();  // 가능
		Func();		// 가능

		// 멤버 변수
		m_StaticA = 10; // 가능
		m_a = 10;       // 가능
	}
private:
	static int m_StaticA;
	int m_a;
};

 

static과 const의 차이점

 

static

-> 선언을 하게 되면 위치와 상관없이 프로그램의 시작부터 끝까지 메모리에 할당되어 있고,

-> 그 값을 마음대로 바꿀 수 있다. 
-> 위치에 대해서는 전역변수든 지역변수든 상관 없다.

 

const

-> 해당 변수를 초기화한 이후에는 절대로 바꾸지 못하도록 선언하는 것

-> 초기화가 되고나면 그 이후에는 값을 바꿀 수 없게 된다.

+ Recent posts