C++ 동적할당

#include <iostream>

using namespace std;

char* Func()
{
char szBuff[16] = "";
cin >> szBuff;

return szBuff;
}

char* Func2();
void main()
{
// 동적 할당
// 사용자가 필요할 때 메모리에 등록하고, 사용자가 필요할 때 메모리에서 해제하는 것.

//// 동적할당의 필요성
//// Func()에서 선언한 szBuff는 지역변수이다.
//// 지역 변수에 값을 입력하여도 함수가 종료되면 메모리가 해제되면서 입력한 값들이 소멸한다.
//// 소멸한 공간의 주소를 가지고 있어도 정상적인 값을 확인할 수 없다!!
//char* pBuff = Func();
//cout << pBuff << endl;


// 동적할당_##1. malloc()
// void* : Heap영역에 할당한 메모리의 시작 주소를 반환한다.
// -> 단, 시작 주소만 반환할 뿐 얼마만큼을 어떤형식으로 읽을지 알 수 없는 상황이다.
// -> 정상적으로 사용하기 위해서는 형 변환이 필요하다.

// size_t _Size : Heap 영역에 얼마만큼 할당할 것인지 전달(byte단위)

//// Heap 영역에 4bytes만큼 공간을 할당한다.
//// 이후 해당 공간의 시작 주소를 반환한다.
//// 단, 시작 주소의 정보만 알 뿐 몇 바이트를 사용할지, 어떤 형식으로 읽을지 모르는 상황이다.
//malloc(4);

//// Heap 영역에 4bytes만큼 공간을 할당하고,
//// 해당 공간의 시작 주소를 반환하는데, int*형으로 형 변환을 시켰다!
//(int*)malloc(4);


//// 메모리 공간을 할당하라고 명령했다!
//// 단, 해제하라고 명령한 적은 없다!!
//// -> 메모리 누수가 남았다!
//int* ptr = (int*)malloc(sizeof(int));

//cout << "ptr: " << ptr << endl;
//cout << "*ptr: " << *ptr << endl;


//// 메모리 공간 해제
//// free()
//free(ptr);
//ptr = nullptr;

//// free함수를 호출하여 메모리 공간을 해제하였으나,
//// ptr은 주소를 그대로 가지고 있다!!
//// 이 때, ptr이 가지고 있는 주소를 Dangling Pointer라고 한다.
//cout << "ptr: " << ptr << endl;


//// Dangling Pointer가 위험한 이유
//// ##1. 할당되지 않은 메모리 접근의 시도가 있을 경우 프로그램 강제로 종료된다.
//// ##2. 다른 곳에서 할당을 받았는데 우연히 주소가 겹치는 경우


//// Dangling Pointer 방지 방법
//// free() 호출 후 변수에 nullptr로 다시 초기화를 진행하자!



// 동적할당_##2. calloc()
// size_t _Count : 몇 개를 할당할 것인지 전달
// -> 배열을 만들겠다!
// 프로그램 가동 중 배열의 크기를 설정할 수 있다!
// -> 동적 배열

//// Heap 영역에 int형 크기만큼(4bytes), 5개의 공간을 만들어라!
//// -> 총 20bytes의 공간을 할당하여라!
//(int*)calloc(5, sizeof(int));


//int iSize = 0;
//cin >> iSize;

//int* ptr = (int*)calloc(iSize, sizeof(int));

//for (int i = 0; i < iSize; ++i)
// //cout << *(ptr + i) << endl;
// cout << ptr[i] << endl;


// malloc과 calloc의 차이점
// ##1. 초기화의 차이점
// malloc : 쓰레기 값 초기화
// calloc : 0 초기화


//// malloc으로 동적 배열 만들기
//int iSize = 0;
//cin >> iSize;

////int* ptr = (int*)calloc(iSize, sizeof(int));
//int* ptr = (int*)malloc(iSize * sizeof(int));

//free(ptr);
//ptr = nullptr;


// 동적할당을 이용한 문제 해결
char* pBuff = Func2();
cout << pBuff << endl;

free(pBuff);
pBuff = nullptr;
}

char* Func2()
{
char* pBuff = (char*)calloc(16, sizeof(char));
cin >> pBuff;

//char szBuff[16] = "";
//cin >> szBuff;

return pBuff;
}

 

#include <iostream>

using namespace std;

char* Func();
void main()
{
// C++ 동적 할당
// malloc과 calloc은 C기반의 동적할당이다!
// -> 더이상 사용하지 않는다.

// new 연산자
// new 연산자 뒤에 명시한 자료형을 토대로
// Heap 영역에 자료형의 크기만큼 공간을 할당한다!
// 이후, 자료형의 포인터형으로 주소를 형 변환하여 반환해준다!!
/*
new 자료형
*/

//(int*)malloc(sizeof(int));
//new int;


//int* ptr = new int;
//cout << "ptr: " << ptr << endl; // Heap 영역의 주소
//cout << "*ptr: " << *ptr << endl; // 해당 주소의 값(쓰레기 값)


//// delete
//// delete를 수행한다해도 Dangling pointer로 인해 위험한 상황이 연출된다.
//// delete이후 nullptr로 초기화하는 습관을들이자!!
//delete ptr;
//ptr = nullptr;

//cout << "ptr: " << ptr << endl; // Dangling Pointer!!!



//// new를 이용한 동적 배열 만들기
//int iSize = 0;
//cin >> iSize;

//int* ptr = new int[iSize];

//for (int i = 0; i < iSize; ++i)
// cout << ptr[i] << endl;

//delete[] ptr;
//ptr = nullptr;


//// C기반의 동적할당과 C++기반의 동적할당의 차이점
//// C++기반의 동적할당은 할당과 동시에 초기화가 가능하다!!!
//// -> C++기반의 초기화를 이용하면 된다.
//int iA = 10; // C기반의 초기화 =
//int iB(20); // C++기반의 초기화 ()

//cout << iA << ", " << iB << endl;


//int* ptr = new int(10);

//cout << *ptr << endl;

//delete ptr;
//ptr = nullptr;


char* pBuff = Func();
cout << pBuff << endl;

delete[] pBuff;
pBuff = nullptr;
}

char* Func()
{
char* pBuff = new char[16];
cin >> pBuff;

return pBuff;
}