IT Note

클래스를 DLL로 만들고 사용하기

클래스를 DLL로 만들고 사용하는 방법을 알아보겠습니다.

클래스 구조 코드 준비하기

헤더파일(.h파일)

#include <iostream>
using std::cout;
using std::endl;

#include <string>
using std::string;

class TestClass 
{
private:
	string stringTest;
	bool boolTest;
	int intTest;

public:
	TestClass();
	~TestClass();

	void SetString(string data);
	void SetBool(bool data);
	void SetInt(int data);

	string GetString();
	bool GetBool();
	int GetInt();
};

cpp파일

#include "ctest.h"

TestClass::TestClass() { cout << "Init TestClass!!" << endl; }
TestClass::~TestClass() { cout << "End TestClass!!" << endl; }

void TestClass::SetString(string data) { stringTest = data; }
void TestClass::SetBool(bool data) { boolTest = data; }
void TestClass::SetInt(int data) { intTest = data; }

string TestClass::GetString() {	return stringTest; }
bool TestClass::GetBool() { return boolTest; }
int TestClass::GetInt() { return intTest; }

위와 같이 DLL로 만들 클래스 구조의 코드를 준비합니다.

DLL Wrapper(래퍼) 선언부 만들기

헤더파일(.h파일)

#include "ctest.h"
#define DLL __declspec(dllexport)

extern "C" {
	DLL TestClass* CreateTestClass();

	DLL void SetString(TestClass* obj, string data);
	DLL void SetBool(TestClass* obj, bool data);
	DLL void SetInt(TestClass* obj, int data);

	DLL string GetString(TestClass* obj);
	DLL bool GetBool(TestClass* obj);
	DLL int GetInt(TestClass* obj);

	DLL void DeleteTestClass(TestClass* obj);
}

코드 설명

일반적인 DLL 만드는 방법과 동일하게 __declspec(dllexport) 명령어를 이용하여 DLL 라이브러리에서 호출가능한 함수로 만들어줍니다.

그리고 DLL에서 네임 맹글링된 함수를 가져오기 어렵기 때문에 extern "C" 명령어를 이용하여 네임 맹글링을 제거합니다.

이제부터 네임 맹글링을 하지않기 때문에 클래스를 사용하려면 클래스를 동적 할당하여 각 함수마다 동적 할당된 클래스의 주소를 알려주어야 합니다.

마지막으로 동적 할당하여 객체를 생성하였기 때문에 꼭 동적 할당 해제하는 함수도 만들어줘야 합니다.

DLL Wrapper(래퍼) 구현부 만들기

cpp파일

#include "ctestDLL.h"

TestClass* CreateTestClass() { return new TestClass(); }

void SetString(TestClass* obj, string data) { obj->SetString(data); }
void SetBool(TestClass* obj, bool data){ obj->SetBool(data); }
void SetInt(TestClass* obj, int data){ obj->SetInt(data); }

string GetString(TestClass* obj) { return obj->GetString(); }
bool GetBool(TestClass* obj){ return obj->GetBool(); }
int GetInt(TestClass* obj){ return obj->GetInt(); }

void DeleteTestClass(TestClass* obj) 
{
	if (obj) {
		delete obj;
		obj = nullptr;
	}
}

코드 설명

new를 이용하여 클래스를 동적할당하는 함수를 구현합니다.

각 함수에서는 동적할당한 클래스의 주소를 받고 동적할당한 클래스에서 함수를 다시 실행시켜야 합니다.

delete를 이용하여 꼭 동적할당해제를 해줘야합니다.

DLL 파일로 만들기

빌드 설정

빌드하기전에 [프로젝트 속성 > 구성 속성 > 일반] 에서 구성 형식을 동적 라이브러리(.dll)인지 꼭 확인해야합니다.

빌드 결과

빌드가 완료 되면 위와같이 dll파일과 lib파일이 생깁니다.

여기서 dll빌드를 하였는데 lib파일이 생기는건 암시적 링킹(Implicit linking)을 하였기 때문입니다. 좀 더 상세한 내용은 아래 포스팅을 통해 확인 할 수 있습니다.

https://rurustory.com/8

DLL 사용하기

이제 DLL을 만들었으니 새로운 프로젝트를 만들어 테스트를 해봅시다.

빌드 설정

1. [프로젝트 속성 > C/C++ > 일반] 에서 추가 포함 디렉터리에 dll의 헤더(.h 파일)가 있는 폴더경로를 설정해줍니다.

2. [프로젝트 속성 > 링커 > 일반] 에서 추가 라이브러리 디렉터리에 dll파일과 lib파일이 있는 폴더경로를 설정해줍니다.

3. [프로젝트 속성 > 링커 > 입력]에서 추가 종속성에 lib파일 이름을 입력해줍니다. 

Main cpp파일

#include "ctestDLL.h"

void main()
{
	TestClass* obj = CreateTestClass();

	SetString(obj, "Ruru TestString");
	SetBool(obj, true);
	SetInt(obj, 200);

	cout << "[GetString] " << GetString(obj) << endl;
	cout << "[GetBool] " << GetBool(obj) << endl;
	cout << "[GetInt] " << GetInt(obj) << endl;
    
	DeleteTestClass(obj);
}

빌드 결과

이제 빌드를 하면 정상적으로 빌드가 되는것을 확인할 수 있습니다.

마무리

지금까지 C++ 클래스를 DLL로 만들고 사용하는 방법이였습니다.

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!

RSA 암호화 알고리즘 사용하기

Crypto++ 라이브러리로 RSA 개인키, 공개키를 생성하고 생성한 키로 암호화, 복호화하는 방법을 알아보겠습니다.

개인키, 공개키를 바이너리 키파일로 생성하기

샘플 코드

AutoSeededRandomPool rng;

RSA::PrivateKey privKey;
RSA::PublicKey pubKey;

privKey.GenerateRandomWithKeySize(rng, 2048);
pubKey = RSA::PublicKey(privKey);

ofstream privFile("private.key", ios::binary);
privKey.Save(FileSink(privFile).Ref() );
privFile.close();

ofstream pubFile("public.key", ios::binary);
pubKey.Save(FileSink(pubFile).Ref());
pubFile.close();

코드 설명

AutoSeededRandomPool rng;

RNG가 제공하는 OS를 사용하여 자체적으로 시드를 생성하는 함수입니다.

RSA::PrivateKey privKey;
RSA::PublicKey pubKey;

개인키, 공개키 객체를 생성합니다.

privKey.GenerateRandomWithKeySize(rng, 2048);

생성한 시드와 키 길이를 전달하여 개인키를 생성합니다.

pubKey = RSA::PublicKey(privKey);

개인키를 이용하여 공개키를 생성합니다.

ofstream privFile("private.key", ios::binary);
privKey.Save(FileSink(privFile).Ref() );
privFile.close();

ofstream pubFile("public.key", ios::binary);
pubKey.Save(FileSink(pubFile).Ref());
pubFile.close();

개인키와 공개키를 파일로 저장합니다.

개인키, 공개키를 Base64 키파일로 생성하기

샘플 코드

AutoSeededRandomPool rng;

RSA::PrivateKey privKey;
RSA::PublicKey pubKey;

privKey.GenerateRandomWithKeySize(rng, 2048);
pubKey = RSA::PublicKey(privKey);

ofstream privFile("private.key", ios::binary);
Base64Encoder privKeySink(new FileSink(privFile), true);
privKey.Save(privKeySink);
privKeySink.MessageEnd();
privFile.close();

ofstream pubFile("public.key", ios::binary);
Base64Encoder pubKeySink(new FileSink(pubFile), true);
pubKey.Save(pubKeySink);
pubKeySink.MessageEnd();
pubFile.close();

코드 설명

개인키, 공개키 생성 코드는 위와 동일하므로 설명을 생략하겠습니다.

ofstream privFile("private.key", ios::binary);
Base64Encoder privKeySink(new FileSink(privFile), true);
privKey.Save(privKeySink);
privKeySink.MessageEnd();
privFile.close();

ofstream pubFile("public.key", ios::binary);
Base64Encoder pubKeySink(new FileSink(pubFile), true);
pubKey.Save(pubKeySink);
pubKeySink.MessageEnd();
pubFile.close();

개인키와 공개키를 Base64로 인코딩하여 파일로 저장합니다.

Base64Encoder를 사용을 하면 반드시 MessageEnd() 함수를 사용해야합니다.

인코딩만 할때는 사용을 안해도 문제가 없었는데 나중에 디코딩할때 비정상적으로 디코딩이 되는 문제가 있었습니다. (이것때문에 엄청난 고생을.. ㅠㅠ) 

개인키, 공개키를 바이너리 문자열로 생성하기

샘플 코드

AutoSeededRandomPool rng;

RSA::PrivateKey privKey;
RSA::PublicKey pubKey;

privKey.GenerateRandomWithKeySize(rng, 2048);
pubKey = RSA::PublicKey(privKey);

string priv;
string pub;

privKey.Save(StringSink(priv).Ref());
pubKey.Save(StringSink(pub).Ref());

코드 설명

개인키, 공개키 생성 코드는 위와 동일하므로 설명을 생략하겠습니다.

string priv;
string pub;

privKey.Save(StringSink(priv).Ref());
pubKey.Save(StringSink(pub).Ref());

개인키와 공개키를 바이너리 문자열로 저장합니다.

string 타입의 변수이지만 바이너리 값이 들어갑니다.

개인키, 공개키를 Base64 문자열로 생성하기

샘플 코드

AutoSeededRandomPool rng;

RSA::PrivateKey privKey;
RSA::PublicKey pubKey;

privKey.GenerateRandomWithKeySize(rng, 2048);
pubKey = RSA::PublicKey(privKey);

string priv;
string pub;

Base64Encoder privKeySink(new StringSink(keyBuf.priv));
privKey.Save(privKeySink);
privKeySink.MessageEnd();

Base64Encoder pubKeySink(new StringSink(keyBuf.pub));
pubKey.Save(pubKeySink);
pubKeySink.MessageEnd();

코드 설명

개인키, 공개키 생성 코드는 위와 동일하므로 설명을 생략하겠습니다.

string priv;
string pub;

Base64Encoder privKeySink(new StringSink(keyBuf.priv));
privKey.Save(privKeySink);
privKeySink.MessageEnd();

Base64Encoder pubKeySink(new StringSink(keyBuf.pub));
pubKey.Save(pubKeySink);
pubKeySink.MessageEnd();

개인키와 공개키를 Base64 문자열로 저장합니다.

파일 생성때와 같은 이유로 꼭 MessageEnd() 함수를 사용해야합니다.

전체 예제 코드

#include <iostream>
using std::cout;
using std::endl;
using std::ofstream;
using std::ifstream;
using std::ios;

#include <string>
using std::string;

#include "rsa.h"
using CryptoPP::RSA;

#include "osrng.h"
using CryptoPP::AutoSeededRandomPool;

#include <files.h>
using CryptoPP::FileSink;
using CryptoPP::FileSource;

#include <filters.h>
using CryptoPP::StringSink;
using CryptoPP::StringSource;

#include <base64.h>
using CryptoPP::Base64Encoder;
using CryptoPP::Base64Decoder;

struct KeyString 
{
	string priv;
	string pub;
};

void GenKeyFile(string fileName) 
{
	AutoSeededRandomPool rng;

	RSA::PrivateKey privKey;
	RSA::PublicKey pubKey;

	/* 개인키 생성 */
	privKey.GenerateRandomWithKeySize(rng, 2048);
	/* 공개키 생성 */
	pubKey = RSA::PublicKey(privKey);

	/* 개인키 가져오기 */
	ofstream privFile(fileName + "_private.key", ios::binary);
	privKey.Save(FileSink(privFile).Ref());
	privFile.close();
	/* 공개키 가져오기 */
	ofstream pubFile(fileName + "_public.key", ios::binary);
	pubKey.Save(FileSink(pubFile).Ref());
	pubFile.close();
}

void GenKeyFileBase64(string fileName) 
{
	AutoSeededRandomPool rng;

	RSA::PrivateKey privKey;
	RSA::PublicKey pubKey;

	/* 개인키 생성 */
	privKey.GenerateRandomWithKeySize(rng, 2048);
	/* 공개키 생성 */
	pubKey = RSA::PublicKey(privKey);

	/* 개인키 가져오기 */
	ofstream privFile(fileName + "_private.key", ios::binary);
	Base64Encoder privKeySink(new FileSink(privFile), true);
	privKey.Save(privKeySink);
	privKeySink.MessageEnd();
	privFile.close();

	/* 공개키 가져오기 */
	ofstream pubFile(fileName + "_public.key", ios::binary);
	Base64Encoder pubKeySink(new FileSink(pubFile), true);
	pubKey.Save(pubKeySink);
	pubKeySink.MessageEnd();
	pubFile.close();
}

KeyString GenKey() 
{
	AutoSeededRandomPool rng;

	RSA::PrivateKey privKey;
	RSA::PublicKey pubKey;

	/* 개인키 생성 */
	privKey.GenerateRandomWithKeySize(rng, 2048);
	/* 공개키 생성 */
	pubKey = RSA::PublicKey(privKey);

	KeyString keyBuf;

	/* 개인키 가져오기 */
	privKey.Save(StringSink(keyBuf.priv).Ref());
	/* 공개키 가져오기 */
	pubKey.Save(StringSink(keyBuf.pub).Ref());

	return keyBuf;
}

KeyString GenKeyBase64() 
{
	AutoSeededRandomPool rng;

	RSA::PrivateKey privKey;
	RSA::PublicKey pubKey;

	/* 개인키 생성 */
	privKey.GenerateRandomWithKeySize(rng, 2048);
	/* 공개키 생성 */
	pubKey = RSA::PublicKey(privKey);

	KeyString keyBuf;

	/* 개인키 가져오기 */
	Base64Encoder privKeySink(new StringSink(keyBuf.priv));
	privKey.Save(privKeySink);
	privKeySink.MessageEnd();

	/* 공개키 가져오기 */
	Base64Encoder pubKeySink(new StringSink(keyBuf.pub));
	pubKey.Save(pubKeySink);
	pubKeySink.MessageEnd();

	return keyBuf;
}

int main()
{
	cout << "\n###############################\n" << endl;
    
	/* Binary 키파일 */
	cout << "Binary KeyFile Start" << endl;
	GenKeyFile("RuruTest");
    
	cout << "\n###############################\n" << endl;

	/* Base64 키파일 */
	cout << "Base64 KeyFile Start" << endl;
	GenKeyFileBase64("RuruTest_Base64");
    
	cout << "\n###############################\n" << endl;

	/* Binary 문자열 키 */
	cout << "Binary Key Start" << endl;
	cout << endl;
    
	KeyString key;
	key = GenKey();

	cout << "PrivateKey:" << endl << key.priv << endl;
	cout << endl;
	cout << "PublicKey:" << endl << key.pub << endl;

	cout << "\n###############################\n" << endl;
    
	/* Base64 문자열 키 */
	cout << "Base64 Key Start" << endl;
	cout << endl;

	KeyString keyBase64;
	keyBase64 = GenKeyBase64();

	cout << "PrivateKey:" << endl << keyBase64.priv << endl;
	cout << endl;
	cout << "PublicKey:" << endl << keyBase64.pub << endl;

	cout << "\n###############################\n" << endl;
    
    return 0;
}

마무리

지금까지 Crypto++ 라이브러리로 RSA 개인키, 공개키 생성하는 방법이였습니다. 다음에는 개인키와 공개키가지고 암호화 복호화하는 방법을 작성 할 예정입니다.

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!

Crypto++ 암호화 오픈 라이브러리

여러가지 암호화 알고리즘을 쉽게 사용할 수 있는 CryptoPP(Crypto++) 라이브러리에 대해 알아봅시다.

암호화 알고리즘 및 컴파일러 지원목록 (8.9 버전 기준)

컴파일러

- Visual Studio 2003 - 2022
GCC 3.3 - 13.1
Apple Clang 4.3 - 12.0
LLVM Clang 2.9 - 14.0
C++ Builder 2015
Intel C++ Compiler 9 - 16.0
Sun Studio 12u1 - 12.7
IBM XL C/C++ 10.0 - 14.0

암호화 알고리즘

좀 더 자세한 내용은 아래 링크에서 확인하시기 바랍니다.

https://cryptopp.com/index.html

라이브러리 소스파일 준비

https://cryptopp.com/downloads.html

홈페이지에서 cryptopp890.zip 파일을 다운받습니다.

Windows 버전

1. 라이브러리 빌드하기

압축해제를 하고 cryptest.sin 파일을 엽니다.

정적 라이브러리를 사용할꺼면 cryptlib, 동적 라이브러리를 사용할꺼면 cryptdll 프로젝트를 시작프로젝트로 설정후 빌드합니다.

저는 정적 라이브러리로 빌드하여 위와같이 cryptlib.lib 파일이 생성되었습니다.

2. 라이브러리 사용하기

이제 라이브러리 테스트를 해볼 프로젝트를 만들어 봅시다.

프로젝트를 만들었으면 아래와 같이 프로젝트 속성을 설정해 줍니다.

C/C++ -> 일반 -> 추가 포함 디렉터리: cryptopp 라이브러리 헤더파일이 있는곳으로 설정합니다.

C/C++ -> 코드 생성 -> 런타임 라이브러리를 다중 스레드(/MT)로 변경해줍니다.

링커 -> 일반 -> 추가 라이브러리 디렉터리를 Crypto++ 라이브러리를 빌드해서 생긴 lib파일이 있는곳으로 설정합니다.

링커 -> 입력 -> 추가 종속성에 lib파일 정보를 설정합니다.

#include <iostream>
using std::cout;
using std::endl;
#include <string>
using std::string;

typedef unsigned char byte;
typedef unsigned long long word64;

#include <base64.h>
using CryptoPP::Base64Encoder;
using CryptoPP::Base64Decoder;

void main()
{
	string stringTest = "Ruru TestString";
	string encTest, decTest;

	/* 인코딩 시작 */
	Base64Encoder encoder;

	encoder.Put((const byte*)stringTest.data(), stringTest.size());
	encoder.MessageEnd();

	word64 encSize = encoder.MaxRetrievable();
	if (encSize)
	{
		encTest.resize(encSize);
		encoder.Get((byte*)&encTest[0], encTest.size());
	}

	cout << "Base64 Encode: " << encTest << endl;

	/* 디코딩 시작 */
	Base64Decoder decoder;

	decoder.Put((byte*)encTest.data(), encTest.size());
	decoder.MessageEnd();

	word64 decSize = decoder.MaxRetrievable();
	if (decSize && decSize <= SIZE_MAX)
	{
		decTest.resize(decSize);
		decoder.Get((byte*)&decTest[0], decTest.size());
	}

	cout << "Base64 Decode: " << decTest << endl;
}

다음은 문자열을 Base64 인코딩, 디코딩 하는 코드입니다. Crypto++ 라이브러리의 네임스페이스는 CryptoPP를 사용합니다. 

빌드를 하면 정상적으로 동작하는것을 확인할 수 있습니다.

Linux 버전

리눅스는 윈도우와 달리 좀더 간편하게 라이브러리를 빌드하고 사용할 수 할수있습니다.

1. 라이브러리 빌드하기

# 압축 해제 #
unzip cryptopp890.zip -d ./cryptopp890

# 압축 해제 폴더로 이동 #
cd cryptopp890

# 정적 라이브러리, 동적 라이브러리, 테스트파일 빌드 #
# 방법 1 #
make static dynamic cryptest.exe

# 방법 2 #
make libcryptopp.a libcryptopp.so cryptest.exe

# 빌드 확인 #
ls *.so *.a *.exe

2. 라이브러리 사용하기

이제 라이브러리가 준비되었으니 테스트파일을 만들어 테스트 해봅시다.

# cryptopp890 폴더에서 뒤로가기 #
cd ..

# 테스트용 cpp파일 생성 #
vi CryptoTest.cpp

#include <iostream>
using std::cout;
using std::endl;
#include <string>
using std::string;

typedef unsigned char byte;
typedef unsigned long long word64;

#include <base64.h>
using CryptoPP::Base64Encoder;
using CryptoPP::Base64Decoder;

int main()
{
	string stringTest = "Ruru TestString";
	string encTest, decTest;

	/* 인코딩 시작 */
	Base64Encoder encoder;

	encoder.Put((const byte*)stringTest.data(), stringTest.size());
	encoder.MessageEnd();

	word64 encSize = encoder.MaxRetrievable();
	if (encSize)
	{
		encTest.resize(encSize);
		encoder.Get((byte*)&encTest[0], encTest.size());
	}

	cout << "Base64 Encode: " << encTest << endl;

	/* 디코딩 시작 */
	Base64Decoder decoder;

	decoder.Put((byte*)encTest.data(), encTest.size());
	decoder.MessageEnd();

	word64 decSize = decoder.MaxRetrievable();
	if (decSize && decSize <= SIZE_MAX)
	{
		decTest.resize(decSize);
		decoder.Get((byte*)&decTest[0], decTest.size());
	}

	cout << "Base64 Decode: " << decTest << endl;
    
    return 0;
}

# 테스트용 cpp파일 빌드 #
g++ -DNDEBUG -g3 -O2 -Wall -Wextra -o CryptoTest CryptoTest.cpp -I ./cryptopp890 ./cryptopp890/libcryptopp.a

윈도우와 똑같이 문자열을 Base64 인코딩, 디코딩 하는 코드입니다. Crypto++ 라이브러리의 네임스페이스는 CryptoPP를 사용합니다. 

빌드를 하면 정상적으로 동작하는것을 확인할 수 있습니다.

마무리

지금까지 Crypto++ 암호화 오픈 라이브러리에 대해 알아보았습니다. 추후 라이브러리를 통해 다양하게 암호화 하는 방법도 정리할 예정입니다.

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!

정적 라이브러리(Static Link Library)와 동적 라이브러리(Dynamic Link Library)

개발을 할 때 자주쓰는 함수가 많아 중복을 최소화 하기위해 또는 협업을 효율적으로 하기위해 등등 각종 여러가지 이유로 라이브러리를 사용하게 되는데 이번 시간에는 라이브러리가 어떤것들이 있는지 알아봅시다.

정적 라이브러리(Static Link Library)

정적 라이브러리는 컴파일을 하는 과정에서 애플리케이션이 필요로하는 라이브러리의 내용을 애플리케이션에다가 복사를 하여 사용하는 방법 입니다.

장단점

장점은 애플리케이션만 있으면 어디서든 실행을 시킬수 있다는 점이 있습니다.

단점은 애플리케이션에 라이브러리의 내용을 복사를 하였기 때문에 자체 용량이 커지며 라이브러리가 변동이 될 경우 애플리케이션을 전체 다시 빌드해야한다는 점이 있습니다.

정적 라이브러리의 확장자

Windows: .lib

Linux: .a

동적 라이브러리(Dynamic Link Library)

동적 라이브러리는 애플리케이션 실행할 떄 메모리에 위치하게 되며 라이브러리의 내용이 필요하게 되면 메모리에 있는 라이브러리를 사용하는 방법입니다.

장단점

장점은 정적 라이브러리를 사용하는 것보다 자체 용량이 작으며 라이브러리가 변동이 될 경우 애플리케이션 전체 빌드할 필요 없이 라이브러리만 바꾸면 된다는 점이 있습니다.

단점은 애플리케이션 실행할 때 라이브러리 파일이 필요하며 버전이 다르거나 호환이 되지 않는다면 사용하지 못하는 점이 있습니다.

동적 라이브러리의 확장자

Windows: .dll

Linux: .so

암시적 링킹(Implicit Linking)과 명시적 링킹(Explicit Linking)

윈도우에서 사용하는 동적 라이브러리(DLL) 에서는 애플리케이션에서 라이브러리를 호출하는 방법에 따라 암시적 링킹과 명시적 링킹으로 나누어집니다.

암시적 링킹(Implicit linking)

애플리케이션 자체에 DLL의 함수 정보를 포함시키는 방법이며 빌드 시 동적 라이브러리인 .dll 파일과 DLL이 제공하고자 하는 함수 정보가 포함되어 있는 .lib 파일이 생성됩니다.

이때 생성되는 .lib 파일은 정적 라이브러리로 생성한 .lib 파일과 확장자가 똑같아 같은 파일로 혼돈할 수 있지만 암시적 링킹으로 인해 생성된 .lib은 오로지 DLL의 제공 함수만 있기때문에 주의하시기 바랍니다.

명시적 링킹(Explicit linking)

애플리케이션이 실행할 때 .dll 파일의 존재만 확인을 하며 호출 할 함수의 주소를 얻어 함수를 실행시키는 방법 입니다.

암시적 링킹의 경우 컴파일러가 자동으로 해주는 경우가 많으며 사용하기 쉽기 때문에 편의성을 중시한다면 암시적 링킹을 사용하는것이 좋고 성능을 중시한다면 명시적 링킹을 사용하는것이 좋습니다.

마무리

지금까지 라이브러리 종류에 대해 알아보았습니다.

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!

extern "C"와 네임 맹글링

오픈소스같은 곳에 보면 extern "C"라는 문법이 종종 보이는데 처음에 보면 이게 뭐하는거지 C로 컴파일 해준다는건가? 아니면 C문법으로 바꾸어 쓰라는건가? 라고 의문이 생길겁니다. 이번엔 extern "C"가 뭐하는 녀석인지 알아봅시다. 

네임 맹글링

extern "C"를 알아보기 전에 네임 맹글링에 대해서 먼저 알아봅시다.

컴파일러들은 컴파일을 할때 다른곳에서 접근할수 있도록 심볼을 만드는 작업을 합니다. 
여기서 함수를 심볼로 만들때 심볼이름을 함수이름 그대로 생성하는 C컴파일러와 달리 C++컴파일러들은 각각 정해진 규칙에 따라 심볼이름을 변경하여 생성합니다. 
이러한 작업을 네임 맹글링이라고 하며 C와 달리 C++에서는 함수 오버로딩 같은 다형성을 지원할 수 있는 이유이기도 합니다. 

그러면 이제 실제로 네임 맹글링이 되고있는지 확인해봅시다.

test_c.c

/* C 코드 */
#include <stdio.h> 

void test()
{
	printf("extern c test!!\n");
}

int main()
{
	test();
	return 0;
}

test_cpp.cpp

/* C++ 코드 */
#include <iostream>
using std::cout;
using std::endl;

void test()
{
	cout << "extern c test!!" << endl;
}

int main()
{
	test();
	return 0;
}

컴파일

# C 컴파일 #
gcc -c test_c.c
gcc -o test_c test_c.o

# C++ 컴파일 #
g++ -c test_cpp.cpp
g++ -o test_cpp test_cpp.o

결과

readelf 명령어를 사용하여 확인해보면 실제로 C로 컴파일한 파일은 test 라는 이름으로 심볼이 생성되었고 C++로 컴파일한 파일은 _Z4testv 라는 이름으로 심볼이 생성된걸 확인할 수 있습니다.

extern "C"

자 그러면 이미 눈치채신 분들도 있을겁니다. 

extern "C"는 네임 맹글링을 사용하지 않는다. 라는 의미로 extern "C"를 선언하면 그 안에 모든 코드들은 네임 맹글링을 하지 않습니다.

그럼 실제로 네임 맹글링 작업을 안하는지 알아봅시다.

test_cpp_extern_c.cpp

/* C++ 코드 */
#include <iostream>
using std::cout;
using std::endl;

extern "C" 
{
	void test()
	{
		cout << "extern c test!!" << endl;
	}
}

int main()
{
	test();
	return 0;
}

컴파일

# C++ extern "C" 컴파일 # 
g++ -c test_cpp_extern_c.cpp
g++ -o test_cpp_extern_c.o

결과

extern "C"를 적용안한 파일에서는 _Z4testv 로 심볼이 생성되었고 extern "C"를 적용한 파일에는 C코드와 마찬가지로 test라는 이름으로 심볼이 생성된걸 확인할 수 있습니다.

마무리

지금까지 extern "C"와 네임 맹글링에 대해서 알아보았습니다.

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!

C++ 클래스 기본적인 사용법

객체지향 언어인 C++의 클래스 사용법에 대해 알아봅시다.

접근 제어 지시자

기본적인 클래스 모양

class 클래스 이름
{
접근 제어 지시자:
    멤버변수
    멤버함수
};

클래스 선언부와 구현부

클래스 선언부: 클래스의 모양을 정의하는 곳이며 보통 헤더파일(.h파일)에 많이 정의합니다.

class TestClass
{
private:
	string stringTest;
    
public:
	void SetString(string data);
};

클래스 구현부: 클래스 선언부에서 정의한 함수들을 실제로 구현하는 곳입니다.

void TestClass::SetString(string data)
{
	cout << "[SetString] " << data << endl;
	stringTest = data;
}

생성자와 소멸자

생성자: 클래스 객체를 생성할때 자동으로 호출되는 함수 입니다. 사용자가 따로 코드작성을 하지 않으면 컴파일러가 알아

생성자 선언부

class TestClass 
{
public:
	TestClass();
};

생성자 구현부

TestClass::TestClass() 
{
	cout << "Init TestClass!!" << endl;
}

소멸자: 생성자와 반대로 클래스 객체가 소멸할때 자동으로 호출되는 함수 입니다. 생성자와 마찬가지로 사용자가 따로  코드작성을 하지 않으면 컴파일러가 알아서 아무런기능이 없는 함수로 만들어 실행합니다.

소멸자 선언부

class TestClass 
{
public:
	~TestClass();
};

소멸자 구현부

TestClass::~TestClass() 
{
	cout << "End TestClass!!" << endl;
}

클래스 객체 생성 및 사용

이제 앞에서 생성한 클래스로 객체를 만들어 사용하는 방법을 알아보겠습니다.

void main() 
{
	/* TestClass 클래스를 obj 이름으로 객체 생성 */
	TestClass obj = TestClass();

	/* 객체 함수 호출 */
	obj.SetString("Ruru TestString");
}

전체 예제 코드

헤더파일(.h파일)

#include <iostream>
using std::cout;
using std::endl;
#include <string>
using std::string;

class TestClass 
{
private:
	string stringTest;
	bool boolTest;
	int intTest;

public:
	TestClass();
	~TestClass();

	void SetString(string data);
	void SetBool(bool data);
	void SetInt(int data);

	string GetString();
	bool GetBool();
	int GetInt();
};

.

cpp파일

#include "ctest.h"

TestClass::TestClass() 
{
	cout << "Init TestClass!!" << endl;
}
TestClass::~TestClass() 
{
	cout << "End TestClass!!" << endl;
}

void TestClass::SetString(string data) 
{
	cout << "[SetString] " << data << endl;
	stringTest = data;
}
void TestClass::SetBool(bool data) 
{
	cout << "[SetBool] " << data << endl;
	boolTest = data;
}
void TestClass::SetInt(int data) 
{
	cout << "[SetInt] " << data << endl;
	intTest = data;
}

string TestClass::GetString() 
{
	return stringTest;
}
bool TestClass::GetBool() 
{
	return boolTest;
}
int TestClass::GetInt() 
{
	return intTest;
}

void main() 
{
	/* TestClass 클래스를 obj 이름으로 객체 생성 */
	TestClass obj = TestClass();

	/* 객체 함수 호출 */
	obj.SetString("Ruru TestString");
	obj.SetBool(true);
	obj.SetInt(200);
    
	cout << "[GetString] " << obj.GetString() << endl;
	cout << "[GetBool] " << obj.GetBool() << endl;
	cout << "[GetInt] " << obj.GetInt() << endl;
}

마무리

이상 C++ 클래스 기본적인 사용법에 대해 알아보았습니다.

잘못된 점이 있거나 궁금한 점이 있다면 언제든지 문의해주시기 바랍니다!