장형이의 일기

C++ 람다에서 클래스 멤버 변수를 복사로 캡쳐하여 사용하면 클래스 자체를 복사한다.

장형이 — Mon, 2 Jun 2025 18:58:11 +0900

개요

C++에서 람다로 복사 캡쳐 하여 클래스의 멤버 변수를 사용하면 멤버 변수만 복사되어 넘어오는 것이 아니고, 클래스 그 자체가 복사된다.

C#에서는 async의 매직 코드로 멤버 변수만 넘어왔었는데, 이 사실을 모르고 C++에서도 비슷하게 사용했다가 복사로 인한 부하가 심각하게 발생하는 문제가 발생하였었다. -_-;;

코드

#include <iostream>

class CMember
{
public:
    CMember() { std::cout << "CMember 기본 생성자" << std::endl; }
    CMember(const CMember& _other) { std::cout << "CMember 복사 생성자" << std::endl; }
};

class CMain {
public:
    CMain() { std::cout << "CMain 기본 생성자" << std::endl; }
    CMain(const CMain& _other) { std::cout << "CMain 복사 생성자" << std::endl; }

    CMember m_Member;
};

void MyFunction(const CMain& _main) {}

int main(int argc, const char* argv[])
{
    CMain main_class;

    std::cout << "**** 람다 생성 ****" << std::endl;
    auto func = [=]() -> void { MyFunction(main_class); };

    return 0;
}

/*
CMember 기본 생성자
CMain 기본 생성자
**** 람다 생성 ****
CMember 기본 생성자
CMain 복사 생성자
*/

자 이렇게 main_class를 복사 캡쳐 모드에서 사용하면 main_class가 복사되어 복사 생성자가 당연히 호출되는 것을 볼 수 있다.

그렇다면 멤버 변수를 사용하면 어떨까?

#include <iostream>

class CMember
{
public:
    CMember() { std::cout << "CMember 기본 생성자" << std::endl; }
    CMember(const CMember& _other) { std::cout << "CMember 복사 생성자" << std::endl; }
};

class CMain {
public:
    CMain() { std::cout << "CMain 기본 생성자" << std::endl; }
    CMain(const CMain& _other) { std::cout << "CMain 복사 생성자" << std::endl; }

    CMember m_Member;
};

void MyFunction(const CMember& _member) {}

int main(int argc, const char* argv[])
{
    CMain main_class;

    std::cout << "**** 람다 생성 ****" << std::endl;
    auto func = [=]() -> void { MyFunction(main_class.m_Member); };

    return 0;
}
/*
CMember 기본 생성자
CMain 기본 생성자
**** 람다 생성 ****
CMember 기본 생성자
CMain 복사 생성자
*/

이렇게 멤버 변수를 사용하도록 바꿨음에도 불구하고 여전히 CMain이 복사되어 사용되는 것을 볼 수 있다.

그래서 거대 클래스의 멤버 변수를 복사 캡쳐 할 때에는 반드시 주의가 필요하다.

#include <iostream>

class CMember
{
public:
    CMember() { std::cout << "CMember 기본 생성자" << std::endl; }
    CMember(const CMember& _other) { std::cout << "CMember 복사 생성자" << std::endl; }
};

class CMain {
public:
    CMain() { std::cout << "CMain 기본 생성자" << std::endl; }
    CMain(const CMain& _other) { std::cout << "CMain 복사 생성자" << std::endl; }

    CMember m_Member;
};

void MyFunction(const CMember& _member) {}

int main(int argc, const char* argv[])
{
    CMain main_class;

    std::cout << "**** 람다 생성 ****" << std::endl;
    CMember _member = main_class.m_Member;
    auto func = [=]() -> void { MyFunction(_member); };

    return 0;
}
/*
CMember 기본 생성자
CMain 기본 생성자
**** 람다 생성 ****
CMember 복사 생성자
CMember 복사 생성자
*/

CMain의 불필요한 복사를 막고 CMember만의 온전한 복사를 하려면 위와 같이 코드를 수정해야 할 것이다.

주절

C++의 캡쳐에서는 모호한 표현(main_class를 복사할 것인가? m_Member만 복사할 것인가?, l, r value는 어떻게 할 것이지?)을 최소화하기 위해서 표현식(main_class.m_Meber)을 캡쳐하는 것을 금하고, 로컬 변수명(main_class)만을 캡쳐 가능하도록 디자인하였다고 한다.

그래서 멤버 변수를 복사 생략 캡쳐하여 사용하면 로컬 변수인 main_class를 캡쳐한다음 멤버 변수로 꺼내 쓰는 방식으로 동작하게 되는 것이다.

여기서 모호함이 다시 생겨나는데 실수하지 않도록 반드시 주의가 필요할 것 같다.

메모리 파편화 + boost, tbb 도구

장형이 — Sun, 30 Mar 2025 20:13:34 +0900

개요

C++ 틱 베이스의 게임 서버에서 std::vector나 std::map을 매 초마다 수만, 수십만 회 생성하고 있는데 N시간이 지나면 이 코드에서 메모리 파편화(추정)가 심해져서 heap 할당 시에 CPU 사용량은 낮아지고 모든 스레드가 직렬화되는 문제가 확인되었다.

위 문제를 해결하기 위해서 pooling, 할당자 관련 도구를 찾다가 간단하게 정리해 보려고 포스팅하였다.

도구 한 줄 정리

boost object pool : 매우 큰 오브젝트 하나하나를 직접 다루기 좋은 도구.
boost pool_allocator : boost object pool 기반으로 할당해 주는 기능.
boost fast_pool_allocator : boost object pool 기반으로 할당해 주는 기능. 단일 스레드 앱에서 최적화.

tbb scalable allocator : 멀티 쓰레드 환경에서 쓰기 좋은 할당자, heap 할당 / 해제에서 직렬화되지 않으며 lock-free 하게 작동, 스레드를 오가면서 오브젝트 주체가 변경되어도 문제없음.

boost object pool 사용법

#include <iostream>
#include <boost/pool/object_pool.hpp>

class Test {
public:
    Test() { std::cout << "Test object created\n"; }
    ~Test() { std::cout << "Test object destroyed\n"; }
};

int main() {
    boost::object_pool<Test> pool;

    Test* obj = pool.construct();
    pool.destroy(obj);

    return 0;
}

할당자 계열(그 외)

#include <iostream>
#include <vector>
#include <boost/pool/pool_alloc.hpp>
#include <tbb/scalable_allocator.h>

int main() {
    std::vector<int, boost::pool_allocator<int>> vec;
    // std::vector<int, boost::fast_pool_allocator<int>> vec;
    // std::vector<int, tbb::scalable_allocator<int>> vec;

    // 1000개의 정수 할당
    for (int i = 0; i < 1000; ++i) {
        vec.push_back(i);
    }

    // 벡터의 값을 출력
    for (const int& val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

결론

이렇게 간단하게 한 줄 추가하는 것 만으로 메모리 파편화가 쉽게 해결되고 풀링을 지원할 수 있다니 최고다!

하지만 어쨌든 좋은 도구를 쓰더라도 저런 단순 컨테이너 따위로 파편화가 발생하는 것은 바람직하지 않으므로 코드 정리도 반드시 하는 게 좋을 것 같다.

우리 프로젝트에서도 문제 클래스의 코드 정리와 tbb를 같이 적용해 두니 문제가 더 이상 문제가 발생되지 않게 개선되었는데 제발 더 이상 문제가 없기를 바란다.

C++ 스마트 포인터 메모리는 shared_ptr가 없어져도 해제되지 않는다.

장형이 — Sun, 30 Mar 2025 19:41:33 +0900

개요

C++ 스마트 포인터 shared_ptr의 참조 카운트가 0이 되어도 weak_ptr이 참조하고 있다면 메모리를 해제하지 않고 소멸자만 부른다.

스마트 포인터 간단 요약

스마트 포인터의 기본 원리는

make_shared시에, control block(스마트 포인터 관리용 오브젝트)와 object(실제 사용하는 오브젝트)가 생성된다.

이후 shared_ptr이 참조할 때마다 use_count가 늘어나고,

weak_ptr이 참조할 때 마다 weak_count가 늘어난다.

use_count가 0이 되면 object의 소멸자가 호출되고,

모든 count가 0이 되면 control block과 object의 메모리가 해제된다.

메모리 해제 시점

상식적으로 use_count가 0이 될 때, object의 메모리를 해제해야 하는 것 아닌가?

하지만 그렇지 않다. 실험을 해보자.

#include <memory>
#include <iostream>
#include <string>

class A{
public:
    int number;
};

int main(int argc, const char * argv[])
{
    A* ptr_a = nullptr;
    // std::weak_ptr<A> weak_ptr_a;
    
    {
        std::shared_ptr<A> shared_ptr_a = std::make_shared<A>();
        shared_ptr_a->number = 500;
        ptr_a = shared_ptr_a.get();
        // weak_ptr_a = shared_ptr_a;
    }
    
    // 주석을 설정하면 My number is 0
    // 주석을 해제하면 My number is 500
    std::cout << "My number is " << ptr_a->number << std::endl;
    
    return 0;
}

이렇게 weak_ptr 유무에 따라서 결과가 달라지는 것을 볼 수있다.

주석 설정시 vs memory debug

주석 해제시 memory debug

위와 같이 visual studio memory debugging에서도 메모리 사용 여부가 잡힌다.

코드 검증

make_shared 단

make_shared시에 생성되는 객체

실제로 make_shared시에 생성되는 _Ref_count_obj2에는 _Ty를 포인터가 아닌 멤버 변수로 바로 만들고 있어서 따로 해제할 수 있는 방법이 없다.

use count 감소 처리단

use count가 줄어 들 경우 호출되는 함수

위 함수에서 호출되는 함수

위 코드를 근거로 use count가 0이되어도 _Obj.~_Ty() 즉 소멸자 호출만 일어나고 메모리 해제는 따로 일어나지 않는 것을 알 수 있다.

weak count 감소 처리단

weak count 감소시에 호출되는 함수

위 함수에서 호출되는 함수

weak count가 0이 될 경우 컨트롤 블록이 delete 되며 멤버 변수로 생성되어 있는 object도 같이 해제되는 모습이다.

왜 그럴까?

왜 저렇게 설계하였는지 명확한 이유는 찾기 힘들지만, Windows/MacOS에서는 그렇게 작동하는 것을 확인하였으며 control block과 object를 같은 메모리 위치에 할당하고 두 객체를 항상 동시에 생성 및 해제시키려고 그렇게 만든 것으로 추정된다.

vprintf, vsprintf 등 가변 인자 함수를 활용한 로그 함수 개발 시에 포맷 warning 출력하기

장형이 — Fri, 5 Apr 2024 22:33:40 +0900

printf

C++에서 printf 사용시에 format을 잘못 지정하였다면 이렇게 컴파일러단에서 C4477 C4313 C6067 의 워링 에러가 발생하여 잘못된 포맷으로 인한 오류나 크래시를 방지 할 수 있다.

vprintf, vsprintf...

하지만 보통 printf를 저렇게 사용하는 일은 거의 없다.

아래와 같이 보통 로그를 남기는 함수를 va_list를 사용하여 커스터마이징하곤 한다. (UE_LOG도..)

하지만 이렇게 사용하면 포맷 관련 warning이 발생하지 않아서 실수를 저지르기가 너무 쉽다.

해결법

MSVS에서는 저런 사용자 함수에서 포맷 체크를 하는 방법이 없어서 이렇게 편법으로 Debug 빌드 시에만 printf로 체크하는 방식이 가능하다.

sizeof() 안에 있는 printf구문은 런타임에 평가되지 않으므로 문제가 발생하지 않으니 걱정하지 않아도 된다.

#include <stdio.h>
#include <stdarg.h>

void Log(const char* szFormat, ...)
{
    va_list lpStart;
    va_start(lpStart, szFormat);

    vprintf(szFormat, lpStart);

    va_end(lpStart);
}

#ifdef _DEBUG
#define CHECK_FORMAT(...)                               \
	do {                                                \
		char const dummy = sizeof(printf(__VA_ARGS__)); \
		(void)dummy;                                    \
	} while (false)
#else
#define CHECK_FORMAT(...) __noop
#endif

#define LOG(...) { CHECK_FORMAT(__VA_ARGS__); Log(__VA_ARGS__); }

int main() {
    int a = 5;
    LOG("a : %s", a);
    return 0;
}

GCC?

이 방법은 MSVC에서만 쓰는 방식이고 GCC에서는 attribute라는 구문으로 포맷 체크를 할 수 있다고 하니 참고 바란다.

attribute((format(printf, formatStringIndex, formatArgStartIndex))).

<p>Support format specifier checking on user-defined fu...

<p>As per: https://devblogs.microsoft.com/cppblog/format-specifiers-checking/</p> <p>I have had a request for formal support of the checking of format...

developercommunity.visualstudio.com

StackWalk64가 context에 의하여 Access violation를 유발

장형이 — Mon, 23 Oct 2023 04:49:30 +0900

#include <iostream>
#include <windows.h>
#include <dbghelp.h>

BOOL InitSymHandler(HANDLE hProcess) {
    if (SymInitialize(hProcess, NULL, TRUE)) {
        SymSetOptions(SYMOPT_LOAD_LINES);
        return TRUE;
    }
    return FALSE;
}

LONG WINAPI UnhandledExceptionHandler(EXCEPTION_POINTERS* exceptionInfo) {
    CONTEXT* context = exceptionInfo->ContextRecord;
    STACKFRAME64 stackFrame;
    memset(&stackFrame, 0, sizeof(STACKFRAME64));

    stackFrame.AddrPC.Mode = AddrModeFlat;
    stackFrame.AddrPC.Offset = context->Rip;
    stackFrame.AddrStack.Mode = AddrModeFlat;
    stackFrame.AddrStack.Offset = context->Rsp;
    stackFrame.AddrFrame.Mode = AddrModeFlat;
    stackFrame.AddrFrame.Offset = context->Rbp;

    while (StackWalk64(
        IMAGE_FILE_MACHINE_AMD64,
        GetCurrentProcess(),
        GetCurrentThread(),
        &stackFrame,
        context,
        NULL,
        SymFunctionTableAccess64,
        SymGetModuleBase64,
        NULL)) {
        DWORD64 address = stackFrame.AddrPC.Offset;
        CHAR buffer[sizeof(SYMBOL_INFO) + 256] = { 0 };
        PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;
        pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
        pSymbol->MaxNameLen = 255;

        if (SymFromAddr(GetCurrentProcess(), address, NULL, pSymbol)) {
            std::string functionName = pSymbol->Name;
            std::cout << "Function: " << functionName << " at 0x" << std::hex << address << std::endl;
        }
        else {
            std::cout << "SymFromAddr failed, error: " << GetLastError() << std::endl;
        }
    }

    return EXCEPTION_CONTINUE_SEARCH;
}

int main()
{
    HANDLE hProcess = GetCurrentProcess();
    InitSymHandler(hProcess);
	SetUnhandledExceptionFilter(UnhandledExceptionHandler);

    char* a = 0;
    *a = 5;
}

/*
출력 :
Function: main at 0x7ff6bd774587
Function: invoke_main at 0x7ff6bd7768f9
Function: __scrt_common_main_seh at 0x7ff6bd77679e
Function: __scrt_common_main at 0x7ff6bd77665e
Function: mainCRTStartup at 0x7ff6bd77698e
Function: BaseThreadInitThunk at 0x7ff8c79b7344
Function: RtlUserThreadStart at 0x7ff8c7b026b1
*/

흔히 사용하는 StackWalk64를 사용하여 stackTrace를 찍는 예제.

이 함수를 그대로 써서 현재 StackTrace를 찍어보고 싶어 개조해보았다.

LONG WINAPI ExceptionHandler(EXCEPTION_POINTERS* exceptionInfo) {
    CONTEXT* context = exceptionInfo->ContextRecord;
    STACKFRAME64 stackFrame;
    memset(&stackFrame, 0, sizeof(STACKFRAME64));

    stackFrame.AddrPC.Mode = AddrModeFlat;
    stackFrame.AddrPC.Offset = context->Rip;
    stackFrame.AddrStack.Mode = AddrModeFlat;
    stackFrame.AddrStack.Offset = context->Rsp;
    stackFrame.AddrFrame.Mode = AddrModeFlat;
    stackFrame.AddrFrame.Offset = context->Rbp;

    while (StackWalk64(
        IMAGE_FILE_MACHINE_AMD64,
        GetCurrentProcess(),
        GetCurrentThread(),
        &stackFrame,
        context,
        NULL,
        SymFunctionTableAccess64,
        SymGetModuleBase64,
        NULL)) {
        DWORD64 address = stackFrame.AddrPC.Offset;
        CHAR buffer[sizeof(SYMBOL_INFO) + 256] = { 0 };
        PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;
        pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
        pSymbol->MaxNameLen = 255;

        if (SymFromAddr(GetCurrentProcess(), address, NULL, pSymbol)) {
            std::string functionName = pSymbol->Name;
            std::cout << "Function: " << functionName << " at 0x" << std::hex << address << std::endl;
        }
        else {
            std::cout << "SymFromAddr failed, error: " << GetLastError() << std::endl;
        }
    }

    return EXCEPTION_EXECUTE_HANDLER;
}

void PrintStackTrace() {
    __try {
        RaiseException(1, 0, 0, NULL);
    } // StackTrace 출력 후 여기서 Access violation이 발생한다.
    __except (ExceptionHandler(GetExceptionInformation())) {
    }
}

int main()
{
    HANDLE hProcess = GetCurrentProcess();
    InitSymHandler(hProcess);

    PrintStackTrace();
}

이렇게 강제로 Exception을 만들어서 StackTrace만 찍고 돌아가려고 했는데, stack unwind하는 과정에서 Access violation exception이 발생한다.

LONG WINAPI ExceptionHandler(EXCEPTION_POINTERS* exceptionInfo) {
    CONTEXT context;
    memcpy(&context, exceptionInfo->ContextRecord, sizeof(CONTEXT));


    STACKFRAME64 stackFrame;
    memset(&stackFrame, 0, sizeof(STACKFRAME64));

    stackFrame.AddrPC.Mode = AddrModeFlat;
    stackFrame.AddrPC.Offset = context.Rip;
    stackFrame.AddrStack.Mode = AddrModeFlat;
    stackFrame.AddrStack.Offset = context.Rsp;
    stackFrame.AddrFrame.Mode = AddrModeFlat;
    stackFrame.AddrFrame.Offset = context.Rbp;

    while (StackWalk64(
        IMAGE_FILE_MACHINE_AMD64,
        GetCurrentProcess(),
        GetCurrentThread(),
        &stackFrame,
        &context,
        NULL,
        SymFunctionTableAccess64,
        SymGetModuleBase64,
        NULL)) {
        DWORD64 address = stackFrame.AddrPC.Offset;
        CHAR buffer[sizeof(SYMBOL_INFO) + 256] = { 0 };
        PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;
        pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
        pSymbol->MaxNameLen = 255;

        if (SymFromAddr(GetCurrentProcess(), address, NULL, pSymbol)) {
            std::string functionName = pSymbol->Name;
            std::cout << "Function: " << functionName << " at 0x" << std::hex << address << std::endl;
        }
        else {
            std::cout << "SymFromAddr failed, error: " << GetLastError() << std::endl;
        }
    }

    return EXCEPTION_EXECUTE_HANDLER;
}

void PrintStackTrace() {
    __try {
        RaiseException(1, 0, 0, NULL);
    }
    __except (ExceptionHandler(GetExceptionInformation())) {
    }
}

int main()
{
    HANDLE hProcess = GetCurrentProcess();
    InitSymHandler(hProcess);

    PrintStackTrace();
}

이렇게 Context를 copy하여 사용하면 문제가 발생하지 않는다.

StackWalk64 함수가 Context를 훼손시키는데, StackTrace 출력 이후 로직에서 ContextRecord를 다시 사용하기 때문에 Exception이 발생하는 것이다.

어찌되었건 이런 방식은 너무 이상하고 느리기 때문에 boost::stacktrace나 더 좋은 도구들을 사용하여서 stackTrace를 출력하는 것이 좋을 것 같다.

C++ 가변인자(va_list)를 오버로딩 하지 말자.

장형이 — Mon, 23 Oct 2023 03:59:32 +0900

#include <iostream>
#include <stdarg.h>

void Print(const char* format, va_list args) { // 2번째 Print 함수에서 호출함
	vprintf(format, args);
}

void Print(const char* format, ...) { // main 에서 호출함
	va_list args;
	va_start(args, format);
	Print(format, args);
	va_end(args);
}

int main()
{
	char a[] = "Hello ";
	char b[] = "world!";

	Print("%s %s", a, b); // "Hello world!" 출력됨.
	return 0;
}

위 코드는 아무 문제가 없다. 가변인자가 잘 들어가서 2번째 Print 함수 -> 1번째 Print를 호출한다.

#include <iostream>
#include <stdarg.h>

void Print(const char* format, va_list args) { // main에서 호출됨.
	vprintf(format, args);
}

void Print(const char* format, ...) { // 호출되지 않음.
	va_list args;
	va_start(args, format);
	Print(format, args);
	va_end(args);
}

int main()
{
	char a[] = "Hello ";

	Print("%s", a); // Access violation 발생.
	return 0;
}

이 코드는 Access violation을 발생시킨다.

va_list는 내부적으로 char* 이기 때문에, a가 va_list로 취급되어 1번째 Print 함수가 실행되고 Exception이 발생한다.

경우에 따라서는 CallStack이 망가져서 디버깅하기 매우 힘들어지니 꼭 절대 가변인자 함수는 오버로딩 하지말고 얌전히 함수명을 분리하자. -_-;;

C++ parallel for_each (thread) exception

장형이 — Mon, 23 Oct 2023 03:37:14 +0900

#include <iostream>
#include <windows.h>
#include <thread>
#include <execution>
#include <vector>
#include <algorithm>

LONG WINAPI UnhandleExceptionHandler(_EXCEPTION_POINTERS* exceptionInfo) {
	std::cout << "Exception catched!"; // 출력되지 않음.
	return 0;
}

int main()
{
	SetUnhandledExceptionFilter(UnhandleExceptionHandler);

	// 쓰레드에서 std::Exception 발생.
	std::thread th1([]() { throw std::exception(); });
	th1.join();

	// parallel for_each에서 std::Exception 발생.
	std::vector<int> vec{ 1,2,3 };
	std::for_each(std::execution::par_unseq, vec.begin(), vec.end(), [](const int& num) {
		throw std::exception();
		});

	std::cout << "fin."; // 출력되지 않음.
}

thread나 for_each는 기본적으로 noexcept로 작동하기 때문에, C++ exception이 발생하면 std::terminate 된다.

그래서 위 코드에서 예외를 잡을 수 없고 아무런 출력도 발생하지 않는다.

void TerminateHandler() {
	std::cout << "Program terminated!"; // 출력됨.
}

int main()
{
	// 쓰레드에서 std::Exception 발생.
	std::thread th1([]() {
		std::set_terminate(TerminateHandler); throw std::exception();
		});
	th1.join();

	// parallel for_each에서 std::Exception 발생.
	std::vector<int> vec{ 1,2,3 };
	std::for_each(std::execution::par_unseq, vec.begin(), vec.end(), [](const int& num) {
		std::set_terminate(TerminateHandler);
		throw std::exception();
	});
}

그래서 위와 같이 TerminateHandler를 통하여 로그를 남기거나,

Thread,Task 관련 로직에 try_catch를 잘 심어두어야 한다.

LONG WINAPI UnhandleExceptionHandler(_EXCEPTION_POINTERS* exceptionInfo) {
	std::cout << "Exception catched!"; // 출력됨.
	return 0;
}

int main()
{
	SetUnhandledExceptionFilter(UnhandleExceptionHandler);

	// 쓰레드에서 SEH Exception 발생.
	std::thread th1([]() { 
		char* a = 0; *a = 5; 
	});
	th1.join();

	// parallel for_each에서 SEH Exception 발생.
	std::vector<int> vec{ 1,2,3 };
	std::for_each(std::execution::par_unseq, vec.begin(), vec.end(), [](const int& num) {
		char* a = 0; *a = 5;
	});

	std::cout << "fin."; // 출력되지 않음.
}

하지만! SEH 예외가 발생하면 UnhandleExceptionHandler를 통해서 잡을 수 있다.

noexcept terminate 로직은 내부적으로 C++ 예외만 잡아서 프로그램을 터트리기 때문이다.

C# -> C++

장형이 — Sat, 26 Aug 2023 01:16:35 +0900

C#으로 만 5년을 근무하다가 드디어 C++을 할 기회가 생겨서 이직하게 되었다.

이제 다시 쌩초보자가 되어 열심히 C++을 공부해야겠다.

두렵고 설렌다.

C# perfmon 샘플 코드

장형이 — Sat, 26 Aug 2023 01:13:28 +0900

internal class Program
{
    const string CategoryName = "JangHyeong";
    const string CounterName = "Test";

    static private bool looping = true;

    // 1초마다 0~99 사이의 값으로 카운터를 남긴다.
    static void Loop()
    {
        var random = new Random();
        var counter = new PerformanceCounter(CategoryName, CounterName, false);
        while (looping)
        {
            counter.RawValue = random.Next(100);
            Thread.Sleep(1000);
        }
    }

    static void Main(string[] args)
    {
        // 없으면 카운터를 생성한다.
        if (PerformanceCounterCategory.Exists(CategoryName) == false)
        {
            CounterCreationData testCounterCreationData = new CounterCreationData();
            testCounterCreationData.CounterName = CounterName;
            testCounterCreationData.CounterType = PerformanceCounterType.NumberOfItems32;

            var jangHyeongCounters = new CounterCreationDataCollection();
            jangHyeongCounters.Add(testCounterCreationData);

            PerformanceCounterCategory.Create(CategoryName, "JangHyeong Test Category", PerformanceCounterCategoryType.SingleInstance, jangHyeongCounters);
        }

        var thread = new Thread(Loop);
        thread.Start();

        Console.WriteLine("Start.");
        Console.ReadLine();
        Console.WriteLine("End.");

        looping = false;
    }
}

1초마다 "JangHyeong"-"Test" 카운터에 0~99의 랜덤한 숫자로 지표를 남기는 프로그램 샘플 코드.

테스트하려고 짰다가 나중에 다시 써먹으려고 포스팅 한다.

C# 람다 클로저 원리

장형이 — Sat, 26 Aug 2023 00:35:55 +0900

개요

C#의 람다식의 사용법과 어떻게 작동하는지 간략하게 정리한다.

람다

int number = 5;

// input에 5를 더하여 리턴하는 익명 함수를 담은 변수 action.
var action = (int input) => { return number + input; };

// 5 + 10이 리턴되어 15가 출력된다.
Console.WriteLine(action(10)); // 출력: 15

위 코드에서 "(int input) => { return number + input; };" 구문을 람다 식이라고 부르며, 함수지만 이름이 없어서 무명 함수(메서드)라고도 부른다.

이때, 익명 함수 외부에서 가져온 변수 number를 캡처된 변수라고 부른다.

그리고 캡처가 완료되어 사용가능한 상태가 된 익명 함수를 클로져라고 부르고, 위 예제에서는 그 클로져를 action이라는 변수가 담고 있다.

캡처는 레퍼런스

int number = 5;

// number라는 캡쳐된 변수에 input을 집어 넣는 무명함수.
// action에 캡쳐가 폐쇄된(closure) 무명함수가 저장되었다.
var action = (int input) => { number = input; };

// action에 인자를 10으로 실행한다.
action(10);

// 실제로 number가 수정되었다.
Console.WriteLine(number); // 출력: 10

캡쳐된 변수는 레퍼런스로 넘어가서 무명 함수 내에서 수정하면 실제로 캡처된 변수의 값이 변경된다.

컴파일러가 생성해내는 람다 코드

public class Program {
    public void Main() {
        int number = 5;
        Console.WriteLine(number);
        
        var action = (int input) => { return number + input; };
        Console.WriteLine(action(10));
    }
}

위 코드를 실제로 컴파일러는 아래의 코드로 생성해 낸다.

[CompilerGenerated]
private sealed class <>c__DisplayClass0_0
{
    public int number;

    internal int <Main>b__0(int input)
    {
        return number + input;
    }
}

public void Main()
{
    <>c__DisplayClass0_0 <>c__DisplayClass0_ = new <>c__DisplayClass0_0();
    <>c__DisplayClass0_.number = 5;
    Console.WriteLine(<>c__DisplayClass0_.number);
    Func<int, int> func = new Func<int, int>(<>c__DisplayClass0_.<Main>b__0);
    Console.WriteLine(func(10));
}

1. 먼저 클래스를 만드는 코드를 추가한다. (<>c__DisplayClass2_0 클래스)

2. 익명 함수를 (1.)에서 만든 클래스 안으로 집어넣는다.

3. 캡처되어야 할 변수를 클래스 멤버 변수로 만든다.

4. 람다를 사용하는 코드에서 (1.)에서 만든 클래스의 객체를 생성하는 코드로 바꾼다.

5. 객체를 생성한 다음에 캡쳐되어야 할 변수를 클래스의 객체 멤버 변수에 넣는다.

6. 캡처된 변수를 사용하는 부분을 모두 (5.)의 객체 멤버 변수를 참조하도록 수정한다.

위처럼 코드가 생성되기 때문에 클로져가 제대로 작동하며, 레퍼런스 타입과 primitive 타입들 모두 캡쳐 변수라면 레퍼런스로 넘어가는 것처럼 처리가 되게 된다.

참고

람다식은 인라인 함수로 생성되며 인라인 최적화 될 수 있다.

C++도 거의 똑같은 원리로 생성해내니 참고하자.
https://sharplab.io/ 사이트에서 컴파일러 생성 코드를 쉽게 확인 할 수 있다.