웅웅이의 지식창고

[c++] 반환값 최적화 (RVO, return-value-optimization)

웅웅이님 — Thu, 26 Sep 2024 14:50:05 +0900

c++ 컴파일러는 빠른 속도를 제공해주기 위해서 다양한 최적화를 제공합니다.

그중에 이번 글에서는 반환값 최적화에 대해서 알아보며 내부 동작을 이해하는 시간을 가져 봅니다.

#include <iostream>
#include <string>
class CTest
{
public:
	CTest()
	{
		std::cout << "CTest Constructor, value : " << m_str.c_str() << std::endl;
	}

	CTest(const std::string & str) : m_str(str)
	{
		std::cout << "CTest Constructor strParam, value : " << m_str.c_str() << std::endl;
	}

	CTest(const CTest & t)
	{
		this->m_str = t.m_str;
		std::cout << "CTest Copy Constructor, value : " << m_str.c_str() << std::endl;
	}

	CTest(CTest&& t) noexcept
	{
		this->m_str = std::move(t.m_str);
		std::cout << "CTest Move Constructor, value : " << m_str.c_str() << std::endl;
	}

	~CTest()
	{
		std::cout << "CTest Destructor, value : " << m_str.c_str() << std::endl;
	}

public:
	std::string m_str;
};

class CTestRapper
{
public:
	CTestRapper(const CTest& ct)
	{
		std::cout << "CTestRapper Constructor" << std::endl;
	}
	~CTestRapper()
	{
		std::cout << "CTestRapper Destructor" << std::endl;
	}
};

// RVO(Return Value Optimization) 예제
CTest CallRVO()
{
	std::cout << "CALL CallRVO Function" << std::endl;
	return CTest("RVO");
}

// NRVO(Named Return Value Optimization) 예제
CTest CallNRVO()
{
	std::cout << "CALL CallNRVO Function" << std::endl;
	CTest tempCTest("NRVO");
	return tempCTest;
}

RVO 동작 방식을 알아 보기 위해서 위와 같은 예제 코드를 준비 하였습니다.

함수의 반환 되는 임시 객체에 std::move 적용

반환값 최적화를 공부하기 전에 Move Sementics를 처음 배우게 되었을 때 시절의 이야기를 해보려고 합니다.

다들 그 당시 다음과 같은 상상을 해본적이 있을 것 같습니다.

"함수 안에서 생성되는 임시 객체에 대한 리턴시 복사 생성이 되고 있으니 해당 로직을 이동 연산을 적용하자."

CTest && CallReturnMove()
{
	std::cout << "CALL CallReturnMove Function" << std::endl;
	CTest tempCTest("NRVO");
	return std::move(tempCTest);
}

int main()
{
	CTest ct = CallReturnMove();
}

위의 로직을 실행 시켜보면 우리가 예상한대로 호출이 되며

CTest의 m_str 객체가 이동연산이 되면 복사 연산보다 더욱 효율적으로 동작하는 것을 확인 할 수 있습니다.

그러나 아쉽게도 해당 로직이 내부적으로 컴파일러에게 잘못된 내용을 전달하여 최적화 수행을 방해하게 되며

"warning C4172: 지역 변수 또는 임시: tempCTest의 주소를 반환하고 있습니다." 같은 warning을 호출 하게 됩니다.

move를 사용한 임시값 반환

RVO 동작 호출

RVO란 return value optimization으로 CallRVO 형태 처럼 return 값을 rvalue로 호출 할 때 동작하는 최적화 기법을 말합니다.

// RVO(Return Value Optimization) 예제
CTest CallRVO()
{
	std::cout << "CALL CallRVO Function" << std::endl;
	return CTest("RVO");
}

/// 생략...

int main()
{
	CTest Ct1 = CallRVO();
}

위의 코드를 실행 시키면 "CTest의 생성자 및 소멸자는 몇 번 호출되어야 할까요?"

코드로 파악해보면 다음과 같은 결과로 출력되어야 할 것으로 예상됩니다.

CallRVO에서 CTest의 생성자 호출, 소멸자 호출(Ct1의 복사 생성 완료 후)
main 함수에서는 CTest의 복사 생성자 호출 및 소멸자 호출

하지만 실제로 실행해보면 다음과 같은 결과를 얻는 것을 확인 할 수 있습니다.

복사 생성자가 호출 되지 않고 있으며 소멸자도 1회만 호출 되고 있습니다. 놀라운 결과 입니다.

RVO 결과

실제 디버깅으로 확인 해보면 다음의 위치에 생성자 및 소멸자가 호출 되는 것을 확인 할 수 있습니다.

CallRVO 함수의 "return CTest("RVO");" 구문에서 CTest의 생성자 호출
Main함수의 중괄호가 끝나는 지점에서 CTest의 소멸자 호출

CallRVO 함수에서 Main함수의 "CTest Ct1" 객체 메모리 주소에 객체를 생성하는 방식으로 최적화가 동작하고 있는 것으로 보입니다.

컴파일러는 매우 똑똑하게 객체의 생성을 최소화 하는 형식으로 최적화 되고 있네요. 든든합니다.

리턴 값이 일치하지 않은 호출

위의 내용을 자세하게 알아보기 위해서 Main에서 CTestRapper를 통해서 CallRVO함수를 결과를 저장하도록 실행해보면 명확하게 알 수 있습니다.

int main()
{
    CTestRapper CtRapper1 = CallRVO();
}

CTestRapper를 사용하면 함수의 리턴 값과 복사생성되는 객체의 타입이 일치 하지 않아 최적화 로직이 실행 되지 않습니다.

코드상으로 보이는 대로 호출 되는 것을 확인 할 수 있습니다. (컴파일러의 최적화 기준에 도달하지 못한 것 같네요..)

CallRVO에서 CTest의 생성자 호출, 소멸자 호출(CtRapper1 생성자 호출 완료 후)
main 함수에서는 CTestRapper의 생성자 호출 및 소멸자 호출

RVO가 실행되지 않았을때 동작

NRVO 동작 호출

NRVO란 named return value optimization으로 CallNRVO 형태 처럼 return 값을 rvalue로 호출 할 때 동작하는 최적화 기법을 말합니다.

RVO와는 다르게 이름을 가진 객체를 리턴하도록 구현하고 있습니다.

// 생략...

// NRVO(Named Return Value Optimization) 예제
CTest CallNRVO()
{
	std::cout << "CALL CallNRVO Function" << std::endl;
	CTest tempCTest("NRVO");
	return tempCTest;
}

int main()
{
	CTest ct2 = CallNRVO();
}

코드로 파악해보면 다음과 같은 결과로 출력되어야 할 것으로 예상됩니다.

CallNRVO에서 CTest의 생성자 호출, 소멸자 호출(Ct1의 복사 생성 완료 후)
main 함수에서는 CTest의 복사 생성자 호출 및 소멸자 호출

하지만 실제로 실행해보면 다음과 같은 결과를 얻는 것을 확인 할 수 있습니다.

디버그 환경

디버그 환경에서는 반환값을 rvalue처럼 판단하여 move 연산을 수행해서 최적화 합니다.

릴리즈 환경

릴리즈 환경에서는 RVO와 같이 동작하는 것을 볼 수 있습니다.

RVO 호출과 같이 컴파일러가 매우 똑똑하게 NRVO를 최적화 해주고 있습니다.

축하합니다. 앞으로 우리는 이러한 구문을 보았을 때 똑똑한 컴파일러에게 감사함을 느끼며

최적화를 믿고 맏길 수 있게 되었습니다.

긴 글을 읽어 주셔서 감사합니다. ( _ _ )

[c++] find_if

웅웅이님 — Sat, 14 Sep 2024 23:03:00 +0900

find_if는 전달된 범위에서 지정된 조건을 만족하는 첫번째 요소를 리턴해줍니다.

함수 정의

함수의 정의를 보시면 순차 검색을 통해서 조건에 만족하는 iterator를 리턴합니다.

// 자세한 구현 사항은 컴파일러를 통해서 정의된 구문을 참조 바랍니다. 
template<class _InIt, class _Pr>
_InIt find_if(_InIt _First, const _InIt _Last, _Pr _Pred) { 
    for (; _First != _Last; ++_First) {
        if (_Pred(*_First)) 
            break;        
    }
    return _First;
}

매개변수	설명
_First	검색할 범위의 첫번째 요소의 iterator
_Last	검색할 범위의 마지막 요소의 iterator
_Pred	검색 조건을 정의하는 사용자 정의 함수 객체입니다. bool(const T& arg)의 형식을 갖춰야 합니다.

기본 사용 구문

아래의 예제는 컨테이너에서 5를 초과하는 요소를 찾는 간단한 예제 구문입니다.

#include <algorithm>
#include <vector>
#include <iostream>

using namespace std;

int main()
{
	vector<int> ints = { 1,2,3,4,5,6,7,8,9,10 };

	// 5 초과 값을 가진 요소를 찾으시오
	const auto findIt = find_if(begin(ints), end(ints), [](int value) { return 5 < value;  });

	std::cout << "findIt : " << *findIt << std::endl; 

	return 0;
}

// 출력 : 6

응용 사용 구문

이번에는 find_if를 실무에서 발생할 수 있는 간단한 사례를 들어서 설명 드립니다.

"주어진 AbilityTicket에서 weight 기반으로 랜덤 뽑기를 구현해주세요. " 다음과 같은 조건으로

개발 요청이 들어 온 경우 컨테이너에서 weight를 검사하여 찾는 구문에 find_if를 사용할 수 있습니다.

#include <algorithm>
#include <vector>
#include <iostream>

using namespace std;

struct AbilityTicket
{
	AbilityTicket(const std::string& name, uint16_t value, uint16_t weight)
		: name(name), value(value), weight(weight)
	{}

	std::string name;					// 이름
	uint16_t	value;					// 값		
	uint16_t	weight;					// 비중
};

vector<AbilityTicket> AbilityLotteryContainer = {
	{"attack", 5, 5},
	{"defense", 5, 5},
	{"critical", 2, 5},
	{"reduction", 3, 3},
	{"hp", 100, 10},
	{"mp", 50, 10}
};

// 리턴값 : 0 ~ (base - 1), 간략한 랜덤 함수
const int getRandomValue(const int base)
{
	return rand() % base;
}

int main()
{
	srand((unsigned int)time(nullptr));

	// 요청 : AbilityLotteryContainer에서 weight를 기반으로 랜덤 옵션 하나를 뽑아주세요
	uint32_t totalWeight{ 0 };
	std::vector<uint32_t> accumulateWeights;
	accumulateWeights.reserve(AbilityLotteryContainer.size());
    
	// ability별 가중도를 accumulateWeights 추가 합니다. 
	for (auto& abilityTicket : AbilityLotteryContainer)
	{
		totalWeight += abilityTicket.weight;
		accumulateWeights.push_back(totalWeight);
	}

	// 랜덤 값 추출
	const auto lot{ static_cast<uint32_t>(getRandomValue(totalWeight)) };

	// lot 값을 기반으로 ability를 찾습니다.(이곳에서 find_if를 사용합니다.)
	const auto findIt = std::find_if(begin(accumulateWeights), end(accumulateWeights),
		[lot](const auto & accumulateWeight)
		{ return lot < accumulateWeight; });

	// 같은 기능을 lower_bound를 통해서 구현 할 수도 있습니다. 
	// const auto findIt2 = std::lower_bound(begin(accumulateWeights), end(accumulateWeights), lot + 1);

	// 값을 찾지 못하였는지 체크 
	if (findIt == end(accumulateWeights)) {
		std::cout << "not find" << '\n';
		return 0;
	}

	// 찾은 인덱스를 구합니다. 
	const auto index = findIt - begin(accumulateWeights);

	std::cout << "lot : " << lot << '\n';
	std::cout << "find Ability : " << AbilityLotteryContainer[index].name << ", " << AbilityLotteryContainer[index].value << " index : " << index << '\n';

	return 0;
}

데이터가 정렬되어 있다면 비슷한 기능을 lower_bound 를 통해서도 구현 할 수 있습니다.

lower_bound는 이진 탐색으로 구현되기에 검색 데이터가 많다면 find_if보다 빠른 검색 속도를 제공합니다.

성능차이가 궁금해서 제 로컬 환경에서 테스트 했을 때 결과를 공유 드리면 다음과 같습니다.

Release 빌드, 최적화를 피하기 위해서 결과 데이터 저장
대략적인 성능 측정 및 테스트 도중에 오차가 있을수 있음을 감안 부탁 드립니다.

Ticket 갯수	성능차이( find_if와 lower_bound의 성능 측정)
100개	약 2배
300개	약 3배
600개	약 6배
1200개	약 10배

참고

https://en.cppreference.com/w/cpp/algorithm/find

std::find, std::find_if, std::find_if_not - cppreference.com

(1) template< class InputIt, class T > InputIt find( InputIt first, InputIt last, const T& value ); (constexpr since C++20) (until C++26) template< class InputIt, class T = typename std::iterator_traits

en.cppreference.com

[설치] SQL Server 2019 Developer 설치하기

웅웅이님 — Fri, 26 Aug 2022 22:54:45 +0900

개발 및 테스트를 위한 무료 버전인 SQL Server 2019를 설치하는 방법에 대해서 알아 봅니다.

https://www.microsoft.com/ko-kr/sql-server/sql-server-downloads 경로에서 설치 파일을 다운 받습니다.

다운 받은 파일을 클릭하면 다음과 같은 화면이 나오게 됩니다.

SQL 설치

기본 : 기본 구성으로 SQL Server 설치
사용자 지정 : 사용자가 지정한대로 SQL Server 설치
미디어 다운로드 : 설치 프로그램을 ISO 또는 CAB 파일로 다운로드 받습니다.

기능 선택 탭에서는 필요한 기능들을 선택 하여 설치 할 수 있습니다.

SQL

데이터 베이스 엔진 구성 탭에서는 인증 모드 방식 및 DB의 데이터 저장 디렉토리, 메모리 설정을 수행할 수 있습니다.

인증 모드에 대해서 간단히 설명을 드리겠습니다.

Windows 인증 모드는 윈도우 사용자를 통해서 SQL Server에 접근하는 인증 방식입니다.

SQL Server 인증 모드는 SQL Server의 사용자를 통해서 SQL Server 접근하는 인증 방식입니다.

아래의 설정에서 혼합 모드를 사용하지 않으면 윈도우 계정을 통해서 접근 할 수 있습니다.

데이터 베이스 엔진 구성 탭

설치가 완료되면 다음과 같은 화면이 나오게 됩니다.

윈도우의 서비스 탭을 확인해보면 다음과 같이 설치되어 있는 것을 확인 할 수 있습니다.

서비스 설치 완료

[c++17] fold expression(폴드 표현식)

웅웅이님 — Wed, 22 Jun 2022 23:09:31 +0900

c++11부터 parameter pack라는 기능이 제공되었습니다.

parameter pack을 사용하면 0개 이상의 템플릿 인자를 사용할 수 있습니다.

아래 예제처럼 템플릿 파라미터를 "typename... Targs" 형식으로 선언하여 가변 인자를 처리 하도록 구성 할 수 있습니다.

#include <iostream>

using namespace std;

template<typename T>
constexpr auto tsum(T value) // 기본 함수
{
    return value;
}

template<typename T, typename... Targs>
constexpr auto tsum(T value, Targs... args) // 재귀 가변 함수
{
    return value + tsum(args...);
}


int main()
{
    constexpr auto sum = tsum(1, 2, 3, 4, 5, 6);
    cout << sum << '\n'; // 21
    return 0;
}

c++ 17부터는 fold expression이 제공되어서 parameter pack을 더욱 손쉽게 사용 할 수 있게 되었습니다.

fold expression 의 테스트 환경

3중 비교 연산자 컴파일러 지원 옵션

Visual Studio 사용시 프로젝트 우 클릭 -> 구성 속성 -> 일반 -> c++ 언어 표준을 ISO C++ 17 이상으로 수정

VisualStudio 버전별 컴파일러 버전

fold expression 사용 예제

fold expression을 사용하면 위에서 설명드린 예제를 쉽게 처리 할 수 있습니다.

#include <iostream>

using namespace std;

template<typename... Targs>
constexpr auto tsum(Targs... args) // 재귀 가변 함수
{
    return (args + ...); // 단항 오른쪽 fold
}

int main()
{
    constexpr auto sum = tsum(1, 2, 3, 4, 5, 6);
    cout << sum << '\n'; // 21

    return 0;
}

fold expression 문법

fold expression은 4가지 문법으로 사용할 수 있습니다.

단항 오른쪽 fold

다음과 같은 문법으로 사용 할 수 있습니다.

pack op ...

template<typename... Args>
auto sum(Args... args) { 
    return (args + ...); 
}

int main(){
    sum(1, 2, 3, 4);
}

단항 오른쪽 fold는 전달받은 parameter pack을 다음과 같은 표현식으로 변경 합니다.

E1 op ( ... op ( En-1 op En))

뒤에 있는 인자 부터 먼저 순차적으로 연산해서 결과 값을 생성합니다.

아래의 코드는 위의 예제를 컴파일러가 어떻게 생성하는지 보여줍니다.

template<typename... Args>
auto sum(Args... args) { 
    return (args + ...); 
}

#ifdef INSIGHTS_USE_TEMPLATE
template<>
int sum<int, int, int, int>(int __args0, int __args1, int __args2, int __args3)
{
    return __args0 + (__args1 + (__args2 + __args3));
}
#endif

int main()
{
    sum(1, 2, 3, 4);
    return 0;
}

단항 왼쪽 fold

... op pack

template<typename... Args>
auto sum(Args... args) { 
    return (... + args); 
}

int main(){
    sum(1, 2, 3, 4);
}

전달받은 parameter pack을 다음과 같은 표현식으로 변경 합니다.

((E1 op E2) op ...) op En

앞에 있는 인자 부터 순차적으로 연산해서 결과 값을 생성합니다.

컴파일러가 생성한 단항 왼쪽 fold는 다음과 같습니다.

// 생략...
template<>
int sum<int, int, int, int>(int __args0, int __args1, int __args2, int __args3)
{
    return ((__args0 + __args1) + __args2) + __args3;
}
// 생략...

이항 오른쪽 fold

단항을 사용하는 문법과 다르게 parameter pack과 별개로 초기 연산할 값을 추가 할 수 있습니다.

pack op ... op init

template<typename ...Args>
int sum(Args&&... args)
{
    return (args + ... + (1 * 2));
}

전달받은 parameter pack을 다음과 같은 표현식으로 변경 합니다.

E1 op ( ... op ( En-1 op ( En op I )))

이항 왼쪽 fold

init op ... op pack

template<typename ...Args>
int sum(Args&&... args)
{
    return ((1 * 2) + ... + args);
}

전달받은 parameter pack을 다음과 같은 표현식으로 변경 합니다.

((( I op E1 ) op E2) op ...) op En

단항 fold에 길이가 0인 parameter pack이 전달이 가능한 경우

AND(&&) 연산자 인경우 true를 리턴 합니다.
OR(||) 연산자인 경우 false를 리턴 합니다.
Comma(,) 연산자 인경우 void를 리턴합니다.

#include <iostream>
using namespace std;

template<typename... Args>
bool all(Args... args) 
{ 
    return (... && args); 
}

template<typename... Args>
bool any(Args... args)
{
    return (... || args);
}

template<typename... Args>
void comma(Args... args)
{
    return (... , args);
}


int main() {
    auto a = all();
    auto b = any();
    //auto c = comma(); // error void 리턴
    comma();

    cout << boolalpha;
    cout << "a : " << a << ", b : " << b << '\n';    // a : true, b : false
}

fold expression으로 만드는 간단한 헬퍼 함수

아래의 예제는 첫번째 인자 컨테이너에 매칭 되는 가변 인자의 수를 리턴하는 함수입니다.

// 전달 받은 가변인수 ts만큼 range를 조회해서 카운트를 구합니다.
template<typename R, typename ... Ts>
auto matches(const R& range, Ts ... ts)
{
    return (std::count(std::begin(range), std::end(range), ts) + ...);
}

void main()
{
    vector<int> v{ 1,2,3,4,5 };
    cout << matches(v, 2, 5) << '\\n';           // 2 반환
    cout << matches(v, 100, 200) << '\\n';       // 0 반환
    cout << matches("abcdefg", 'x', 'y', 'z') << '\\n';       // 0 반환
    cout << matches("abcdefg", 'a', 'd', 'f') << '\\n';       // 3 반환

}

다음 예제는 Set에 가변인자를 insert하고 모두 성공했는지 확인 하는 헬퍼함수입니다.

// 전달 받은 가변인수 모두를 set에 삽입하고 모두 성공했는지 반환 받습니다.
template<typename T, typename ... Ts>
bool insert_all(T & set, Ts ... ts){
    // set.insert의 반환 값을 pair<iterator, bool>의 값을 가짐
    return (set.insert(ts).second && ...);
}

void main()
{
    set<int> my_set{ 1, 2, 3 };
    cout << insert_all(my_set, 4, 5, 6) << '\\n';        // true
    cout << insert_all(my_set, 7, 8, 2) << '\\n';        // false => 2 값을 insert 중복으로 false
}

[c++20] 3중 비교 연산자 (<=>)

웅웅이님 — Sat, 18 Jun 2022 09:20:25 +0900

c++20에서는 3중 비교 연산자(<=>)가 추가 되었습니다.

우주선과 비슷하게 생겨서 우주선 연산자라고 불리웁니다.

3중 비교 연산자는 주어진 A와 B에 대해서 A < B인지, 또는 A == B 인지, A > B인지 판정합니다.

3중 비교 연산자의 테스트 환경

3중 비교 연산자 컴파일러 지원 옵션

또한 프로젝트 우 클릭 -> 구성 속성 -> 일반 -> c++ 언어 표준을 ISO C++ 20 표준으로 수정하였습니다.

c++ 언어 표준 변경

VisualStudio 버전별 컴파일러 버전

c++ 20 이전의 순서 판정

3중 비교 연산자의 편리함을 소개 하기 위해서 c++20 이전에 상등/대소 관계 연산자를 설명 드립니다.

c++20 이전에는 ==, !=, >, >=, <, <= 연산자 중에 하나라도 정의 했다면 나머지 관계들도 모두 정의 해야 합니다.

(어떠한 형식을 직관적으로 사용하려면 최소한 SemiRegular(준정규) 형식을 충족 해야 합니다.)

struct MyInt {
    int value; 
    explicit MyInt(int val) : value{val} {}
    bool operator == ( const MyInt & rhs) const {
        return value == rhs.value;
    }
    bool operator != ( const MyInt & rhs) const {
        return !(*this == rhs);
    }
    bool operator < ( const MyInt & rhs) const {
        return value < rhs.value;
    }
    
    bool operator <= ( const MyInt & rhs) const {
        return !(rhs < *this)
    }
    bool operator > ( const MyInt & rhs) const {
        return rhs < *this;
    }
    bool operator >= ( const MyInt & rhs) const {
        return !(*this < rhs);
    }
};

c++ 20 부터의 순서 판정

c++20 부터는 3중 비교 연산자를 직접 정의 하거나 = default 를 사용해서 컴파일러에 의해 생성된 연산자를 사용할 수

있습니다.

3중 비교 연산자를 사용하면 코드 중복을 크게 줄일 수 있습니다.

#include <iostream>
#include <compare>

using namespace std;

struct MyInt {
    int value;
    explicit MyInt(int val) : value{ val } {}

    auto operator==(const MyInt& rhs) const {
        return value == rhs.value;
    }
    // 3중 비교 연산자에 대한 명시적 선언
    auto operator<=>(const MyInt& rhs) const {
        return value <=> rhs.value;
    }
};

struct MyIntDefualt {
    int value;
    // 3중 비교 연산자에 대한 암시적 선언
    explicit MyIntDefualt(int val) : value{ val } {}
    auto operator<=>(const MyIntDefualt& rhs) const = default;
};

int main()
{   
    cout << boolalpha;

    MyInt myInt1(2017);
    MyInt myInt2(2020);

    cout << (myInt1 < myInt2) << '\n';  // true
    cout << (myInt1 > myInt2) << '\n';  // false
    cout << (myInt1 == myInt2) << '\n';  // false

    MyIntDefualt myIntD1(2017);
    MyIntDefualt myIntD2(2020);
    cout << (myIntD1 < myIntD2) << '\n';  // true
    cout << (myIntD1 > myIntD2) << '\n';  // false
    cout << (myIntD1 == myIntD2) << '\n';  // false
}

3중 비교 연산자 구현 방식

3중 비교 연산자의 구현 방식을 설명 드리기 전에 c++20의 비교 범주(comparison category) 설명을 진행 하겠습니다.

비교 범주(comparison category)

비교 범주는 3가지 성질의 성립 여부를 체크해야 합니다.

관계 연산자 성질
- T는 여섯가지 비교 연산자(==, !=, < ,<=,>,>=)를 모두 지원해야 합니다.
동치(equivalent) 성질
- T의 객체 A와 B가 동치일 때는 f(A) 와 f(B)의 결과도 동일 해야 합니다.
  - f는 전달받은 인수를 읽기 전용으로 사용한다고 가정합니다.
- 즉 동치인 값은 구별 할 수 없습니다.
비교 가능 성질
- T의 모든 값은 비교 가능 해야 합니다.
- A와 B에 대해서 A < B, A == B, A > B 중에 하나가 참이어야 합니다.
  - 예를 들어 부동소수점은 Nan을 가질 수 있는데 이 값은 비교 가능 성질을 충족하지 못합니다.

비교 범주 성질	std::strong_ordering	std::weak_ordering	std::partial_ordering
관계 연산자 성질	성립	성립	성립
비교 가능 성질	성립	성립
동치(equivalent) 성질	성립

3중 비교 연산자 리턴 값

3중 비교 연산자는 문맥에 따라서 std::strong_ordering, std::weak_ordering, std::partial_ordering를 리턴합니다.

(예를 들어 객체가 가지고 있는 변수들이 비교 범주를 얼마나 충족하느냐에 따라서 달라짐)

3종류의 객체들의 구현내용을 확인해 보면 다음과 같은 단순한 구조로 되어 있습니다.

구조체이며 _Compare_t(signed char) 형식의 `_Value`라는 하나의 멤버 변수를 가집니다.
리터럴 0과 비교하는 operator들이 선언되어 있습니다.
자주 사용하는 불변 객체(less, greater, equal, equivalent, unordered)를 전역 상수로 등록하여 최적화 합니다.
- less : -1
- greater : 1
- equal : 0
- equivalent : 0
- unordered : -128

_Value에 대한 설정 조건은 첫번째 인자를 기준으로 두번째 인수와의 관계에 따라서 다름과 같이 설정 됩니다.

작다면 less(-1)
같으면 equal(0), equivalent (0)
크다면 greater(1)
알수 없다면 unordered(-128)

#include <iostream>
#include <compare>

using namespace std;

struct MyInt {
    int value;
    // 3중 비교 연산자에 대한 암시적 선언
    explicit MyInt(int val) : value{ val } {}
    auto operator<=>(const MyInt& rhs) const = default;
};


int main()
{   
    MyInt cpp17(2017);
    MyInt cpp20(2020);

    // result_threeway = strong_ordering::less(-1)
    auto result_threeway_le = cpp17 <=> cpp20;
    // result_threeway = strong_ordering::greater(1)
    auto result_threeway_gr = cpp20 <=> cpp17;
    // result_threeway = strong_ordering::equal(0)
    auto result_threeway_eq = cpp20 <=> cpp20;
   
    cout << boolalpha;
    cout << "result_threeway_le : " << (result_threeway_le < 0) << '\n';  // true
    cout << "result_threeway_gr : " << (result_threeway_gr > 0) << '\n';  // true
    cout << "result_threeway_eq : " << (result_threeway_eq == 0) << '\n';  // true
}

표현식 재작성

c++ 20에서는 표현식 재작성이라는 개념이 적용 됩니다.

// 비교 연산자들이 다음의 형태로 변경 됩니다.
a OP b    ==>    (a <=> b) OP 0

기존 코드	변경 코드
a > b	(a <=> b) > 0
a >= b	(a <=> b) >= 0
a < b	(a <=> b) < 0
a <= b	(a <=> b) <= 0

위와 같은 구조로 되어 있기 때문에 3중 비교 연산자로 비교 연산자를 처리할 수 있습니다.

// 원본 코드
#include <iostream>
#include <compare>

using namespace std;

struct MyInt {
    //생략..
};

int main()
{   
    MyInt cpp17(2017);
    MyInt cpp20(2020);
    
    auto result1 = cpp17 == cpp20;
    auto result2 = cpp17 != cpp20;
    auto result3 = cpp17 < cpp20;
    auto result4 = cpp17 <= cpp20;
    auto result5 = cpp17 > cpp20;
    auto result6 = cpp17 >= cpp20;
    
}

cppInsights 라는 곳을 이용하면 컴파일러에 의해 재작성된 구문을 확인 할 수 있습니다.

// 컴파일러에 의해서 재작성된 구문
#include <iostream>
#include <compare>

using namespace std;

struct MyInt
{
  // 생략..
  inline constexpr std::strong_ordering operator<=>(const MyInt & rhs) const noexcept = default;
  // ==는 따로 구현됩니다. 
  inline constexpr bool operator==(const MyInt & rhs) const noexcept = default;
};


int main()
{
  MyInt cpp17 = MyInt(2017);
  MyInt cpp20 = MyInt(2020);
  
  // cpp17 == cpp20
  bool result1 = cpp17.operator==(cpp20);
  // !(cpp17 == cpp20)
  bool result2 = !cpp17.operator==(cpp20);
  // (cpp17 <=> cpp20) < 0
  bool result3 = operator<(cpp17.operator<=>(cpp20), __cmp_cat::__unspec(0));
  // (cpp17 <=> cpp20) <= 0
  bool result4 = operator<=(cpp17.operator<=>(cpp20), __cmp_cat::__unspec(0));
  // (cpp17 <=> cpp20) > 0
  bool result5 = operator>(cpp17.operator<=>(cpp20), __cmp_cat::__unspec(0));
  // (cpp17 <=> cpp20) >= 0
  bool result6 = operator>=(cpp17.operator<=>(cpp20), __cmp_cat::__unspec(0));
  return 0;
}

컴파일러 생성하는 3중 비교 연산자

위에서 설명드린 c++ Insights 라는 사이트를 이용하면 컴파일러에 의해 생성되는 3중 비교 연산자를 확인 할 수 있습니다.

operator== 의 정의도 추가되는 것을 확인 할 수 있습니다.

// c++Insights 에서 생성되는 암시적 3중 연산자
#include <compare>
struct MyInt
{
  int value;
  inline explicit MyInt(int val)
  : value{val}
  {
  }
  
  inline constexpr std::strong_ordering operator<=>(const MyInt & rhs) const /* noexcept */ = default;
  inline constexpr bool operator==(const MyInt & rhs) const /* noexcept */ = default;
};

컴파일 시점 비교

컴파일러에 의해서 생성되는 3중 비교 연산자는 constexpr 이므로 문맥에 따라서 컴파일 시점에 사용 할 수 있습니다.

아래 예제에서는 MyInt D1, D2를 리터럴 값을 통해서 생성하기 때문에 컴파일 시점에 사용 할 수 있는 변수가 되었고

3중 비교 연산자도 컴파일 시점에 수행 될 수 있습니다.

struct MyInt {
    int value;
    // 생성자를 constexpr로 지정합니다.
    explicit constexpr MyInt(int val) : value{ val } {}
    auto operator<=>(const MyInt& rhs) const = default;
};


int main()
{   
	// 인자를 리터럴로 전달 받았으므로 D1, D2 컴파일 시점에 사용 가능
    constexpr MyInt D1(2017);
    constexpr MyInt D2(2020);

    // operator<=> 수식도 constexpr 이므로 컴파일 시점 사용 가능
    constexpr bool res = (D1 < D2);

    cout << boolalpha;
    cout << "D1 < D2 : " << res << '\n';

    return 0;
}

어휘순 비교

컴파일러가 생성한 3중 비교 연산자는 어휘순 비교를 사용합니다.

어휘순 비교란 모든 기반 클래스의 모든 비정적(non-static) 멤버들을 선언 순서대로 비교 하는 것을 말합니다.

아래 예제서는 Lexico를 어휘순으로 비교 할 때는 a -> b -> c -> d -> e 순서대로 비교를 진행합니다.

struct Basics {
    int a;
    float b;
    double c;
    char d;
    auto operator<=>(const Basics &) const = default;
};

struct Lexico : public Basics {
    int e;
    auto operator<=>(const Lexico&) const = default;

};


int main()
{   
    constexpr Lexico l1 = { 1, 2.0f, 3.0f, 4, 5 };
    constexpr Lexico l2 = { 1, 2.0f, 3.0f, 4, 5 };

    cout << boolalpha;
    cout << "l1 == l2 : " << (l1 == l2) << '\n';
    cout << "l1 != l2 : " << (l1 != l2) << '\n';
    cout << "l1 < l2 : " << (l1 < l2) << '\n';
    cout << "l1 <= l2 : " << (l1 <= l2) << '\n';
    cout << "l1 > l2 : " << (l1 > l2) << '\n';
    cout << "l1 >= l2 : " << (l1 >= l2) << '\n';

    /* 
    [결 과]
    l1 == l2 : true
    l1 != l2 : false
    l1 < l2 : false
    l1 <= l2 : true
    l1 > l2 : false
    l1 >= l2 : true
    */

    // 어휘 순으로 비교하다가 e에서 l4가 크다는 판정 확인
    constexpr Lexico l3 = { 1, 2.0f, 3.0f, 4, 5 };
    constexpr Lexico l4 = { 1, 2.0f, 3.0f, 4, 6 };
    cout << boolalpha;
    cout << "l3 == l4 : " << (l3 == l4) << '\n';
    cout << "l3 != l4 : " << (l3 != l4) << '\n';
    cout << "l3 < l4 : " << (l3 < l4) << '\n';
    cout << "l3 <= l4 : " << (l3 <= l4) << '\n';
    cout << "l3 > l4 : " << (l3 > l4) << '\n';
    cout << "l3 >= l4 : " << (l3 >= l4) << '\n';

    /*
    [결 과]
    l3 == l4 : false
    l3 != l4 : true
    l3 < l4 : true
    l3 <= l4 : true
    l3 > l4 : false
    l3 >= l4 : false
    */

    return 0;
}

최적화된 == 연산자와 != 연산자

비교 연산을 할 때 문자열이나 벡터 같은 형식들에 대해서는 최적화할 여지가 있습니다.

전체 비교전에 객체의 길이를 먼저 비교 한 후에 다르다면 false를 리턴하는 최적화를 진행 할 수 있습니다.

하지만 컴파일러가 생성하는 3중 비교 연산자는 어휘순 비교를 통해서 처음부터 끝까지 비교 합니다.

이러한 수정 사항을 P1185R2라는 수정안이 발표 했고 msvc에서는 2019 16.2 버전에 적용 되었음을 확인 할 수 있습니다.

https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1185r2.html

다음과 같이 수정합니다.

template<typename T>
bool operator==(vector<T> const& lhs, vector<T> const& rhs)
{
    // short-circuit on size early
    const size_t size = lhs.size();
    if (size != rhs.size()) {
        return false;
    }

    for (size_t i = 0; i != size; ++i) {
        // use ==, not <=>, in all nested comparisons
        if (lhs[i] != rhs[i]) {
            return false;
        }
    }

    return true;
}

참조

https://en.cppreference.com/w/cpp/language/operator_comparison#Three-way_comparison

https://en.cppreference.com/w/cpp/language/default_comparisons

Default comparisons (since C++20) - cppreference.com

Provides a way to request the compiler to generate consistent comparison operators for a class. [edit] Syntax return-type class-name::operatorop( const class-name & ) const &(optional) = default; (1) friend return-type operatorop( const class-name &, const

en.cppreference.com

[c++20] consteval과 constinit

웅웅이님 — Thu, 16 Jun 2022 22:39:10 +0900

c++ 20에서는 consteval과 constinit라는 두가지 키워드가 추가되었습니다.

consteval과 constinit의 테스트 환경

컴파일러 지원 버전

VisualStudio 버전별 컴파일러 버전

또한 프로젝트 우 클릭 -> 구성 속성 -> 일반 -> c++ 언어 표준을 ISO C++ 20 표준으로 수정하였습니다.

C++ 언어 표준 변경

consteval

consteval은 immediate function(즉시 함수)를 생성합니다.

immediate function란 하나의 컴파일 상수로 평가되는 함수로 컴파일 시점에 실행됩니다

즉시 함수는 암묵적으로 인라인 함수가 되며 다음의 조건을 충족 해야 합니다.

소멸자나 메모리를 할당, 재할당하는 함수 적용 불가
constexpr 함수의 요구 조건

아래 예제를 보시면 지역 변수 const int a와 리터럴 5의 경우는 컴파일 시점에 인식 할 수 있는 값이라서

컴파일 시점에 consteval함수인 sqr의 상수식을 만드는데 문제가 없습니다.

지역 변수 int b의 경우 컴파일 시점에 값을 알 수 없기 때문에 b를 통해서 sqr 상수식을 만드려고 할 때 컴파일 에러가 발생합니다.

#include <iostream>

using namespace std;

// consteval 함수 
// 하나의 컴파일 상수로 평가됩니다.
consteval int sqr(int n) {
    return n * n;
}


int main()
{
    cout << "sqr(5) : " << sqr(5) << '\n';

    const int a = 5;
    cout << "sqr(a) : " << sqr(a) << '\n';

    int b = 5;
    // cout << "sqr(b) : " << sqr(b) << '\n';  // 컴파일 에러 E3133 consteval 함수 "sqr" 호출에서 유효한 상수 식이 생성되지 않았습니다.
}

https://cppinsights.io/ 사이트에서 컴파일러가 어떻게 consteval을 변환하는지 확인해 볼 수 있습니다.

아래는 컴파일러가 생성한 sqr 함수입니다.

inline 키워드를 붙이는 것을 확인 할 수 있습니다.

// consteval 함수 
// 하나의 컴파일 상수로 평가됩니다.
inline consteval int sqr(int n)
{
  return n * n;
}

consteval 와 constexpr 함수의 차이점

c++ 11에 추가된 constexpr과의 차이점은 무엇인지 확인 해 보도록 하겠습니다.

함수 타입	함수의 성격
constexpr	문맥 또는 최적화에 따라서 컴파일 시점 또는 런타임 시점에도 실행 가능
consteval	반드시 컴파일 시점에만 실행 가능

해당 내용을 명확하게 인지하고 상황에 따라서 키워드를 선택 하여 사용 할 수 있습니다.

#include <iostream>

using namespace std;

// 런타임에 평가 됩니다.
const int sqrRuntime(int n) {
    return n * n;
}

// 하나의 컴파일 상수로 평가됩니다.
consteval int sqrCompileTime(int n) {
    return n * n;
}

// 입력 값에 따라서 컴파일 또는 런타임에 평가 됩니다.
constexpr int sqrRunOrCompileTime(int n) {
    return n * n;
}


int main()
{
    // constexpr 변수는 컴파일 타임에 초기화 되어야 합니다.
    // constexpr auto val1 = sqrRuntime(10);  // 에러 E0028 : 식에 상수 값이 있어야 합니다.
    constexpr auto val2 = sqrCompileTime(10);  // 컴파일 시점
    constexpr auto val3 = sqrRunOrCompileTime(10);  // 컴파일 시점

    int x = 100;

    auto val4 = sqrRuntime(x);  // 런타임 시점
    // auto val5 = sqrCompileTime(x);  // 에러 E3133 : consteval 함수 xxx 호출에서 유횽한 상수 식이 생성되지 않앗습니다.
    auto val6 = sqrRunOrCompileTime(x);  // 컴파일 또는 런타임 시점
}

constexpr에 대해서 더 자세히 확인 하시려면 제가 이전에 쓴 글을 참조 부탁드리겠습니다.

https://jungwoong.tistory.com/54?category=1102341

[c++] constexpr 키워드

일반적인 설명 constexpr 키워드는 c++11에서 소개되고 c++14에서 개선되었습니다. (visual studio 2015부터 지원합니다.) constexpr은 상수식 이며 const처럼 변수에 적용 할 수 있으며 해당 변수에 대한 변.

jungwoong.tistory.com

constinit

constinit 키워드는 저장 기간(storage duration)이 정적이거나 스레드인 변수에 적용 할 수 있습니다.

주의 점은 지역 변수에 적용 할 수 없습니다.

constinit를 변수에 적용하면 컴파일 시점에 초기화 됩니다. 주의 할 점은 상수(const) 형식으로 지정하지 않습니다.

const char* g() { return "dynamic initialization"; }
constexpr const char* f(bool p) { return p ? "constant initializer" : g(); }

constinit const char* c = f(true);  // OK
// constinit const char* d = f(false);  // error  E0028 : 식에 상수 값이 있어야 합니다.

변수 초기화

변수 초기화시 const, constexpr, constinit의 차이점에 대해서 예제로 알아 봅니다.

변수의 타입	변수 초기화 성격
const	상수, 런타임 시점까지 초기화 지연 가능
constexpr	상수, 컴파일 시점 초기화
constinit	비상수, 컴파일 시점 초기화, 지역 변수 선언 불가

#include <iostream>

using namespace std;

// 상수
constexpr int constexprVal = 1000;
// 비상수
constinit int constinitVal = 1000;


int main()
{    
	const auto constVal = 1000;
	cout << "constVal: " << constVal << '\n';

	//cout << "++constVal: " << ++constVal << '\n';  // 에러
	//cout << "++constexprVal: " << ++constexprVal << '\n';  // 에러
	cout << "++constinitVal: " << ++constinitVal << '\n';  // OK

	constexpr auto localConstexpr = 1000; //  OK
	// constinit auto localConstexpr = 1000; //  에러 : 지멱 변수가 될 수 없습니다.

}

Static Initialization Order Fiasco(정적 변수 초기화 실패)

Static Initialization Order Fiasco란 코드의 서로 다른 번역 단위(다른 cpp 파일)에 있는 정적 저장기간의 변수들이 순서에

의존적인 문제를 말합니다.

이것에 대해서 설명드리기 전에 정적 변수의 초기화 방식에 대해서 먼저 설명을 드린 후에 진행하도록 하겠습니다.

정적 변수 초기화 방식

정적 단계(컴파일 시점)에서 상수 표현식을 초기화 할 수 있다면 정적 변수는 해당 상수 값으로 초기화 하고

만약 초기화 할 수 없다면 0으로 셋팅합니다.

동적 단계(런타임 시점)에서 초기화 되지 않은 정적 변수를 실행 시점의 값으로 초기화 합니다.

아래의 예제 소스를 보시면 staticA와 staticB가 서로 다른 번역 단위에서 있으면서 의존 관계로 묶여 있습니다,

staticB의 값을 초기화 하려면 staticA 값이 필요합니다.

staticA값은 컴파일 단계에서 초기화 할 수 없기 때문에 기본 값인 0으로 셋팅 후에 런타임에서 초기화 됩니다.

이런 경우 번역 단위의 초기화 순서에 따라서 staticB의 값이 달라집니다.

// SIOF1.cpp
int sum(int l, int r){
    return l + r;
}

auto staticA = sum(1, 2);

// main.cpp
#include <iostream>
using namespace std;

extern int staticA;
auto staticB = staticA;

int main() {
 
    cout << "staticB : " << staticB << "\n";
}

이러한 문제점을 명확하게 보여주기 위해서는 cl 컴파일러를 통해서 빌드를 진행하였습니다.

# cpp 파일들의 obj 생성 작업
cl.exe /c main.cpp SIOF1.cpp

# SIOF1.obj 먼저 초기화되는 링크 순서
cl.exe /Fe:test1.exe SIOF1.obj main.obj # test1.exe 파일 생성
test1.exe # staticB : 3 출력

# main.obj 먼저 초기화되는 링크 순서
cl.exe /Fe:test2.exe main.obj SIOF1.obj # test2.exe 파일 생성
test2.exe # staticB : 0 출력

c++20 이전의 해결 방법

c++20 이전에는 이 문제를 해결하기 위해서 지역 범위 정적 변수의 지연 초기화를 사용 하였습니다.

지역 범위에 있는 정적 변수는 처음 사용 될 때 생성된 다는 규칙을 통해서 순서의 의존성을 해결 합니다.

// SIOF1.cpp
int sum(int l, int r){
    return l + r;
}

int & staticA() {
    // 지역 범위 정적 변수는 처음 사용 될 때 생성 됩니다. 
    static auto staticA = sum(1, 2);
    return staticA;
}

// main.cpp
#include <iostream>
using namespace std;

int & staticA();
// 링크 순서와 상관 없이 이곳에서 처음 사용 되기에 staticB은 일정한 값을 가집니다. 
auto staticB = staticA();

// 생략

c++20에서 해결 방법

c++20에서는 constinit 키워드가 추가되었기 때문에 쉽고 깔끔하게 해결 할 수 있습니다.

constint를 사용하면 반드시 컴파일 시점에 초기화 되는 것을 보장 할 수 있습니다.

// SIOF1.cpp
// constexpr는 컴파일 시점에 평가 할 수 있다면 컴파일 시점 평가 함수로 평가 됩니다.
constexpr int sum(int l, int r){
    return l + r;
}

// staticA는 컴파일 시점에 초기화 됩니다.
constinit auto staticA = sum(1, 2);

// main.cpp
#include <iostream>
using namespace std;

extern constinit int staticA;
auto staticB = staticA;

// 생략

[c++20] module(모듈)

웅웅이님 — Mon, 13 Jun 2022 21:26:28 +0900

Module의 테스트 환경

concept를 지원하는 컴파일러 버전을 확인하시려면 다음의 경로에서 확인 할 수 있습니다

https://en.cppreference.com/w/cpp/compiler_support/20

module 컴파일러 지원 버전

저의 경우 MSVC 2019 community 16.11.15 버전이고 컴파일러 버전은 19.29을 사용하였습니다.

사용한 컴파일러 버전

또한 프로젝트 우 클릭 -> 구성 속성 -> 일반 -> c++ 언어 표준을 ISO C++ 20 표준으로 수정하였습니다.

C++ 컴파일러 버전 변경

모듈을 설명하기 전에 모듈이 도입되어야 했던 이유를 설명하기 위해서 기존의 c++ 빌드 과정과

문제점에 대해서 먼저 알아보겠습니다.

기존의 C++ 빌드 과정

c++빌드 과정(https://st-lab.tistory.com/176)

C++ 프로그램의 빌드 과정은 전처리, 컴파일, 링크로 구성됩니다.

전처리(Preprocessor)

전처리기는 소스 파일에 있는 #include나 #define 같은 지시문들을 처리합니다.

#include 지시문을 헤더 파일로 치환하고 #define 지시문도 정의된 매크로로 치환합니다.

#if, #else, #elif, #ifdef, #ifndef , #endif 같은 지시문을 기반으로 조건부 처리로 포함하거나 제외합니다.

전처리기에서 생성된 구문을 번역 단위(translation unit) 라고 불리우고 이것을 컴파일러에 전달 합니다.

컴파일(compilation)

컴파일 과정에서는 전달 받은 번역 단위에 담긴 c++ 소스 코드를 해석해서 어셈블리 코드로 변환합니다.

어셈블리 코드에 대응 되는 이진 파일을 출력하는데 이것을 목적(object) 파일이라고 합니다.

목적 파일들은 목적 파일이 정의하지 않은 Symbol들도 참조 할 수 있습니다.

링크(linking)

목적(Object) 파일들을 링크해서 하나의 실행 파일이나 공유, 정적 라이브러리 파일을 만듭니다.

여기서 목적 파일들의 Symbol을 검사해서 정상적인 참조인지 확인합니다.

빌드 과정의 문제점

치환 문제

아래와 같이 선언된 간단한 프로그램이 있다고 생각해봅니다.

// main.cpp
int main()
{
    return 0;
}

// main1.cpp
#include <iostream>
int main()
{
    return 0;
}

cl이나 g++ 명령어에 옵션을 통해서 빌드과정에서 생성되는 번역단위를 확인 할 수 있습니다.

# msvc의 경우
cl.exe /std:c++20 /c main.cpp /E > trans.log
cl.exe /std:c++20 /c main1.cpp /E > trans1.log

# gcc의 경우
g++ -E main.cpp > trans.log
g++ -E main1.cpp > trans1.log

생성된 번역단위 크기

간단한 프로그램을 동작하는데 trans1.log 크기가 큰 것을 확인 할 수 있습니다.

#include <iostream>에 의한 치환 과정에서 iostream에서 참조하는 헤더들과 또 그 헤더들이 참조하는 헤더들이

중첩적인 과정을 통해서 번역 단위가 커지는 것을 확인 할 수 있습니다.

전처리 매크로의 위험

매크로는 단순한 텍스트 치환으로 동작하는데 c++의 의미론과 무관하게 동작합니다.

// common.h
#define SIZE	10

// item.h
#define SIZE	100

다음과 같이 같은 전처리 매크로 값에 충돌이 발생하고 cpp 파일에서 두 헤더를 참조한다고 할 때

순서를 어떻게 하느냐에 따라서 "SIZE" 값이 달라집니다.

기호 중복 정의

c++에는 ODR이라는 용어가 있는데 One Definition Rule 입니다.

번역 단위나 프로그램에서 함수의 선언은 하나이어야 합니다.

c++에서는 해당 중복 정의를 회피하기 위해서 포함 가드(include guard)를 사용합니다.

// header.h
// #pragma once
#ifndef FUNC_H
#define FUNC_H

void func1() {

#endif

모듈의 장점

모듈은 단 한번만 도입되며 비용이 거의 없습니다.
모듈을 도입하는 순서에 따른 차이가 없습니다.
모듈에서는 기호 중복 정의 문제가 거의 발생하지 않습니다.
모듈은 코드의 논리적 구조를 표현하는데 유리합니다.
- 명시적으로 노출할 대상을 지정할 수 있습니다.
- 다수의 모듈을 모아서 하나의 논리적 패키지로 제공할 수 있습니다.
소스 코드를 인터페이스 부분과 구현 부분으로 분리할 필요가 없습니다.

모듈의 구조

컴파일러 별 모듈 파일

컴파일러 별로 모듈에 대한 확장자를 다르게 설정 하였습니다.

MSVC의 경우 ixx 확장자를 모듈로 사용합니다.
Clang의 경우 cppm 확장자를 사용 했으나 최근에는 cpp를 사용합니다.
GCC의 경우 모듈 파일에 대해 특별한 확장자를 사용하지 않습니다.

모듈의 구조

module로 시작하는 구문과 모듈의 선언 사이에는 전역 모듈 조각이라는 공간이 존재합니다.
- 전역 모듈 조각에는 아직 모듈화 되지 않은 헤더 파일을 추가 할 수 있습니다.
'export module xxx'은 모듈의 선언입니다. 여기서 부터 모듈이 시작됩니다.
- 클라이언트는 선언된 모듈 이름을 통해서 모듈을 사용 할 수 있습니다.
모듈안에서 참조할 모듈을 import를 통해서 가져올 수 있습니다.
내보낼 모듈들은 export namespace로 선언된 공간에 선언합니다.
내보내지 않을 선언들은 export를 포함하지 않고 선언합니다.

module; // 전역 모듈 조각

#include <string>		// 아직 모듈화 되지 않는 라이브러리 헤더

export module test;     // 모듈 선언, 여기서 부터 모듈 시작
import test2            // 사용할 모듈

// 내부에서만 사용할 선언들
const char* _getName() { return "test"; }

// 외부에 노출할 선언들
export namespace test {
	std::string name() { return std::string{ _getName() }; }
}

모듈 인터페이스 단위와 모듈 구현 단위

모듈이 커지면 모듈을 하나의 모듈 인터페이스 단위와 하나 이상의 모듈 구현 단위로 분할 하는 것을 권장합니다.

모듈 인터페이스

모듈 인터페이스에는 모듈 선언을 내보내는 선언이 있어야 합니다. ("export module math")

모듈이 내보낼 함수들을 정의합니다. 하나의 모듈에는 모듈 인터페이스는 하나이어야 합니다.

module;

#include <string>

export module math;

export namespace math {
    int add(int fir, int sec);
    int sub(int fir, int sec);

    class Vec {
    public:
        std::string getName();
    };
}

모듈 구현 단위

모듈 구현 단위에도 모듈 선언이 있어야 하지만 export는 붙이지 않습니다.

하나의 모듈에 여러개의 모듈 구현 단위가 있을 수 있습니다.

// mathImplementationUnit.cpp
module;
#include <numeric>
#include <string>

module math;

namespace math {
    int add(int fir, int sec) {
        return fir + sec;
    }

    int sub(int fir, int sec) {
        return fir - sec;
    }

    std::string Vec::getName() {
        return std::string{ "Vec" };
    }
}

cpp에서 모듈 사용 예제

// main.cpp
import math;
#include <iostream>


int main()
{
    math::Vec vec;
    auto a = vec.getName();
    std::cout << a << std::endl;
    return 0;
}

하위 모듈

모듈이 더욱 더 커지면 하위 모듈이나 모듈 분할이라는 방식으로 더 작은 단위로 관리 할수 있습니다.

아래 예제에서는 math를 math.math1, math.math2라는 하위 모듈로 나눠서 정의합니다.

// mathModule.ixx
export module math;

export module math.math1;
export module math.math2;

// mathModule1.ixx
export module math.math1;
export int add(int fir, int sec) {
    return fir + sec;
}

// mathModule2.ixx
export module math.math1;
export int sub(int fir, int sec) {
        return fir - sec;
}

사용자는 다음과 같이 사용 할 수 있습니다.

#include <iostream>
import math;

int main() {
    cout << '\n';
    cout << "add(3,4): " << add(3,4) << '\n';
    cout << "sub(3,4): " << sub(3,4) << '\n';
}

또는 직접 하위 모듈에 접근해서 사용 할 수도 있습니다.

// mathModuleClient1.cpp
// 하위 모듈을 직접 접근 할 수 있습니다. 
#include <iostream>
import math.math1;

int main() {
    cout << '\n';
    cout << "add(3,4): " << add(3,4) << '\n';
}

헤더 단위

헤더 단위(header unit)란 전통적인 헤더에서 모듈로 넘어가기 위한 방법입니다.

단순히 #include 지시문에서 import 지시자로 바꾸고 세미콜론(;)을 붙이면 됩니다.

#include <iostream> => import <iostream>;

#include "MyHeader.h" => import "MyHeader.h";

이렇게 헤더 단위를 사용하면 컴파일러는 모듈에서 export 한것 처럼 처리하기 때문에

기존의 #include 보다 빠릅니다.

헤더 단위의 단점

모든 헤더를 헤더 단위로 도입할 수 없습니다.

c++ 표준 라이브러리는 도입 가능하지만 C 헤더들은 도입 불가입니다.

MSVC에서 STL 라이브러리를 헤더 단위로 사용해보기

msdn에서는 2가지 방법을 제시합니다ㅏ.

STL 라이브러리의 헤더 단위 정적 라이브러리 만들기
STL 헤더를 검색하고 헤더 단위로 컴파일 하는 방법

여기서는 간단한 2번째 방법으로 진행해봅니다.

프로젝트 옵션 설정

프로젝트 속성 페이지로 이동합니다.

구성, 플랫폼을 모든 구성, 모든 플랫폼으로 수정합니다.
구성 속성 -> C/C++ -> 일반의 아래 속성을 다음과 같이 변경합니다.

설정 후에 다음과 같이 입력후 빌드를 실행합니다.

첫 실행시에 include 지시문으로 import 지시문으로 변환하는데 시간이 오래 걸립니다.

import math;
import <iostream>;


int main()
{
    std::cout << "import 빌드 완료" << std::endl;
    return 0;
}

참조

https://docs.microsoft.com/ko-kr/cpp/build/walkthrough-import-stl-header-units?view=msvc-160

연습: STL 라이브러리를 헤더 단위로 가져오기

헤더 단위를 사용하여 Visual Studio에서 C++ STL(표준 템플릿 라이브러리) 라이브러리를 가져오는 방법을 알아봅니다.

docs.microsoft.com

[c++20] Concept

웅웅이님 — Fri, 10 Jun 2022 23:11:11 +0900

Concept의 테스트 환경

concept를 지원하는 컴파일러 버전을 확인하시려면 다음의 경로에서 확인 할 수 있습니다

https://en.cppreference.com/w/cpp/compiler_support/20

concept 컴파일러 지원 버전

VisualStudio 버전별 컴파일러 버전

또한 프로젝트 우 클릭 -> 구성 속성 -> 일반 -> c++ 언어 표준을 ISO C++ 20 표준으로 수정하였습니다.

C++ 컴파일러 버전 변경

Concept이 나오게 된 배경

c++ 20 이전에는 함수나 클래스에 접근 하는 방식은 다음과 같았습니다.

명시적인(specific) 호출
템플릿을 사용한 generic 호출

명시적인 호출을 사용한 방식을 사용하면 필요한 모든 데이터 형식에 대한 모든 함수를 Overloading 해야 합니다.

하지만 이 작업은 많은 비용이 소모되기도 합니다.

그렇다고 c++의 암묵적인 변환을 사용하게 되면 의도치 않은 문제가 발생합니다.

void printInt(int i) {
    std::cout << i << '\n';
}

template<typename T>
auto add(T first, T second) {
    return first + second;
}

int main()
{
    printInt(true);         // 암시적 변환 : 1

    printInt(3.15);         // 암시적 변환  : 3

    // bool -> int로 승격
    // ret은 int로 변경
    cout << add(true, false) << "\n";  // 암시적 변환  : 1
}

이러한 문제를 해결 하기 위해서 함수 템플릿이나 클래스 템플릿을 사용 할 수 있지만

명시적인 제약 사항이 존재하지 않아서 이러한 문제로 오류 발생시 문제를 검출하기가 까다로웠습니다.

std::list<int> myList{ 1, 10, 3, 2, 5 };

// std::sort는 임의 접근 반복자만 허용합니다. 
// 사용자는 임의 접근 반복자만 요구하는 것을 명시적으로 알 수 없습니다.
// 복잡한 오류 메시지가 사용자를 반겨줍니다.
std::sort(begin(myList), end(myList));

위와 같은 문제를 해결하기 위해서 c++20에서는 Concept라는 개념이 추가되었습니다.

Concept는 컴파일 시점의 술어로써 템플릿 매개변수에 의미론적(sementic)인 제약을 가합니다.

위의 예시에서의 std::sort에 std::random_access_iterator라는 concept를 제약 사항으로 설정 한 다면

list의 iterator는 std::bidirectional_iterator의 콘셉트만 지원하고 std::random_access_iterator는

지원하지 않는다는 명확한 오류 메시지를 전달 할 수 있다는 장점을 가집니다.

Concept의 장점

템플릿 매개변수에 대한 요구 조건들이 인터페이스의 일부가 됩니다.
콘셉트를 기반으로 함수를 중복 적재하거나 클래스 템플릿을 특수화 할 수 있습니다.
클래스나 클래스 템플릿의 일반적 멤버 함수에도 콘셉트를 적용 할 수 있습니다.
컴파일러는 템플릿 매개변수에 대한 요구 조건들을 기반으로 좀 더 개선된 오류 메시지를 생성 할 수 있습니다.
다른 사람들과 미리 정의한 콘셉트를 활용 할 수 있습니다.
auto와 콘셉트 용법이 통합 되었습니다. auto 대신 콘셉트를 사용 할 수 있습니다.
- c++ 14에서는 일반적 람다가 도입되었습니다.
- c++ 20에서는 제약 있는 자리표(contrained placeholder)와 제약 없는 자리표(uncontrained placeholder)을 사용하면 auto로 선언된 함수가 있으면 자동으로 템플릿 함수로 변환됩니다.
함수 선언에 콘셉트가 있으면 그 함수 선언은 자동으로 함수 템플릿이 됩니다.

Concept의 적용 방법

콘셉트를 적용하는 여러 가지 방법에 대해서 예제로 공유드립니다.

requires 절 선언

requires라는 키워드로 시작하는 requires 절은 템플릿 매개변수나 함수 선언에 대한 요구 조건 또는 제약을 서술 합니다.

requires 키워드 다음에는 다음과 같은 형식이 올 수 있습니다.

하나의 명명된 콘셉트
명명된 콘셉트의 논리곱(&&)이나 논리 합(||)
requires 표현식 같은 컴파일 시점 술어(compile-time predicate)

// require 절 행
// 하나의 명명된 콘셉트가 사용됨
template<typename T>
requires std::integral<T>
auto gcd(T a, T b) {
    if (b == 0) return a;
    else return gcd(b, a % b);
}

// 명명된 콘셉트의 논리곱(&&)
template<typename T>
requires std::integral<T> && std::movable<T>
auto gcd2(T a, T b) {
    if (b == 0) return a;
    else return gcd(b, a % b);
}
// 비형식 인수 컴파일 시점 술어
template<int i>
requires(i >= 0)
int64_t multiplication(int j)
{
    return (i * j);
}

int main()
{
    // std::integral는 템플릿 매개 변수를 기본형 정수로 제한합니다.
    cout << gcd(10, 100) << '\n';  // 10
    //cout << gcd(10.0f, 100.0f) << '\n';  // error 관련 제약 조건이 충족되지 않습니다.

    cout << multiplication<2>(3) << '\n';  // 6;
    //cout << multiplication<-1>(3) << '\n';  // error 관련 제약 조건이 충족되지 않습니다.
}

후행 require 절 선언

// 후행 requires 절 행
// 하나의 명명된 콘셉트가 사용됨
template<typename T>
auto gcd(T a, T b) requires std::integral<T> {
    if (b == 0) return a;
    else return gcd1(b, a % b);
};

템플릿 매개변수로 사용

템플릿 매개변수에 콘셉트를 지정할 수 도 있습니다.

// 제약이 있는 템플릿 매개변수
template<std::integral T>
auto gcd(T a, T b){
    if (b == 0) return a;
    else return gcd2(b, a % b);
}

// 단축 함수 템플릿 - 제약 있는 형식 매개변수 
// 이 형태만 a와 b의 형식이 다를 수 있습니다.
std::integral auto gcd1(std::integral auto a, std::integral auto b){
    if (b == 0) return a;
    else return gcd3(b, a % b);
}

template<typename T>
struct Test {};

// 템플릿 특수화로 사용된 콘셉트
template<std::regular Reg>
struct Test<Reg> {};

// 가변 인수 템플릿에서 사용
template<std::integral... Args>
bool all(Args... args) { return (... && args);  }

template<std::integral... Args>
bool any(Args... args) { return (... || args); }

template<std::integral... Args>
bool none(Args... args) { return !(... || args); }

int main()
{
    Test<int> t;        // std:regular를 통한 특수화
    Test<int&> t2;      // 일반 템플릿 Test 구조체 호출   
    
    cout << all(5, true, false) << '\n';        // false
    cout << any(5, true, false) << '\n';        // true
    cout << none(5, true, false) << '\n';      // false
}

함수 중복 적재(overloading)에서 사용

함수 중복 적재시에도 콘셉트를 지정 할 수 있습니다.

void overload(auto t) {
    cout << "auto : " << t << '\n';
}

// 콘셉트를 사용해서 범위를 지정할 수 있습니다. 
void overload(std::integral auto t) {
    cout << "integral : " << t << '\n';
}

void overload(long l) {
    cout << "long : " << l << '\n';
}


int main()
{
    overload(3.14);  // auto : 3.14
    overload(2020);  // integral : 2020
    overload(2022L);  // long : 2022
}

Concept의 정의 방법

// concept 정의 구문
template <template-parameter-list>
concept concept-name = constraint-expression;

constraint-expression은 다음 중 하나입니다.

기존 concept나 컴파일 시점 술어의 논리 조합
- 논리 조합에는 논리 연산자( &&, ||, ! ) 을 사용할 수 있습니다.
- 컴파일 시점의 술어는 컴파일 시점에 bool 값을 돌려주는 호출 가능 객체 입니다.

// concepts 파일에 정의된 integral, signed_integral, unsigned_integral의 형식

// integral은 is_integral_v 컴파일 술어를 사용해서 정의합니다.
template <class _Ty>
concept integral = is_integral_v<_Ty>;

// unsigned_integral은 콘셉트인 integral, signed_integral을 사용해서 정의합니다.
template <class _Ty>
concept unsigned_integral = integral<_Ty> && !signed_integral<_Ty>;

// signed_integral는 콘셉트인 integral을 사용해서 정의합니다. 
// static_cast<_Ty>(-1) < static_cast<_Ty>(0) 컴파일 술어를 사용
template <class _Ty>
concept signed_integral = integral<_Ty> && static_cast<_Ty>(-1) < static_cast<_Ty>(0);

요구조건 표현식

// 요구 조건 표현식 
// parameter-list : 함수 선언의 파라미터와 같음
// requirement-seq : 단순 요구조건, 형식 요구조건, 복합 요구 조건, 중첩 요구 조건으로 구성된 순차열
requires ( parameter-list(optional) ) { requirement-seq }

요구 조건 표현식 종류

단순 요구 조건

아래 예제와 같이 괄호에 묶여서 선언되어 사용됩니다.

// Addable는 T타입에 대해서 a + b 표현식이 유효해야 합니다.
template<typename T>
concept Addable = requires(T a, T b) {
	a + b;
};

// Subtractable는 T타입에 대해서  a - b 표현식이 유효해야 합니다.
template<typename T>
concept Subtractable = requires(T a, T b) {
	a - b;
};

// Swappable은 T, U가 swap 표현식을 만족 해야 합니다.
template<typename T, typename U = T>
concept Swappable = requires(T&& t, U&& u)
{
    swap(std::forward<T>(t), std::forward<U>(u));
    swap(std::forward<U>(u), std::forward<T>(t));
};

형식 요구 조건

형식 요구 조건을 표현 할 때는 typename과 형식 이름을 사용합니다.

template<typename T>
using Ref = T&;

template<typename T>
concept RequirementType = requires {
    // T가 key_type을 가져야 합니다. 
    typename T::key_type;
    typename T::allocator_type;
    // Ref를 T로 인스턴스화 할 수 있어야 합니다.
    typename Ref<T>;
};

auto printValueType(RequirementType auto a) {
    cout << typeid(a).name() << endl;
}

int main()
{
    // printValueType(std::vector<int>{1, 2, 3});  // 관련 제약 조건이 충족되지 않습니다
    printValueType(std::map<int, int>{ {1, 2}, { 2, 3 }, { 3, 4 } });
}

복합 요구 조건

복합 요구 조건이 단순 요구 조건가 다른 점은

퓨현식에 {}(중괄호)를 감싸야 합니다.
noexcept 지정자와 반환 형식 요구조건을 추가로 붙일 수 있습니다.

// 복합 요구 조건은 다음의 형식을 만족해야 합니다.
{ expression } noexcept(optional) return-type-requirement(optional) ;		


template<typename T>
concept C2 = requires(T x)
{
    // *x라는 표현식이 유효해야 합니다
    // T::inner라는 타입도 유효 해야 합니다. 
    // *x의 결과는 T::inner로 변환 가능해야합니다.
    {*x} -> std::convertible_to<typename T::inner>;
 
    // x + 1라는 표현식이 유효 해야 하며 그 결과가 int형식이어야 합니다.
    {x + 1} -> std::same_as<int>;
};

중첩 요구 조건

중첩 요구 조건은 requires안에 requires로 시작하는 표현식이 있는 것을 말합니다.

template<class T>
concept Semiregular = DefaultConstructible<T> &&
    CopyConstructible<T> && Destructible<T> && CopyAssignable<T> &&
requires(T a, size_t n)
{  
    requires Same<T*, decltype(&a)>; // 중첩 요구 조건
    requires Same<T*, decltype(new T)>; // 중첩 요구 조건
    requires Same<T*, decltype(new T[n])>; // 중첩 요구 조건
    { a.~T() } noexcept; // 복합 요구 조건
    { delete new T }; // 복합 요구 조건
    { delete new T[n] }; // 복합 요구 조건
};

미리 정의된 Concept

매번 concept를 만드는 것 보다는 미리 정의된 concept를 재사용하는 것을 권장합니다.

추가로 미리 정의된 concept의 정의로 이동해서 구현 방식을 참고하는 것이 concept의 사용방법을 익히는데

많은 도움이 됩니다.

이름	설명
std::three_way_comparable<T, U>	<=>연산자 a <=> b 일때 a가 작으면 -1, 같으면 0, a가 크면 1을 리턴합니다. 다음의 조건을 만족하는지 체크합니다. 1. (a <=> b == 0) == bool(a == b)가 true 2. (a <=> b != 0) == bool(a != b)가 true 3. ( (a <=> b) <=> 0) 와 ( 0 <=> (a <=> b) )가 상등(equal) 4. (a <=> b < 0) == bool(a < b)가 true 5. (a <=> b > 0) == bool(a > b)가 true 6. (a <=> b <= 0) == bool(a <= b)가 true 7. (a <=> b >= 0) == bool(a >= b)가 true
std::same_as<T, U>	두 형식이 같은지 체크
std::derived_from<T, U>	template<class _Derived, class _Base> 형식의 콘셉트 첫번째 인자가 두번째 인자의 파생 형식인지 체크
std::convertible_to<T, U>	template <class _From, class _To> 형식의 콘셉트 첫번째 인자가 두번째 인자로 변환이 가능하지 체크 std::convertible_to<char* , std::string> : true std::convertible_to<std::string, char*> : false
std::common_reference_with<T, U>	두 형식을 어떤 공통의 참조 형식으로 변환 할 수 있음 std::common_reference_with<T, U>일 때 T, U가 어떤 형식 참조형식인 C로 변환 가능 체크
std::common_with<T, U>	std::common_reference_with 비슷한데 참조형식이 아니고 값 형식이여도 가능
std::assignable_from<T, U>	std::assignable_from<_LTy, _RTy> _LTy이 참조 형식이어야 하고 _RTy을 _LTy으로 배정 할 수 있어야 합니다.
std::swappable<T, U>	두 형식의 값을 교환 할 수 있음
std::integral<T>	정수 형식(char, short, int, long, unsigned 형식)
std::signed_integral<T>	부호 있는 정수 형식(char, short, int, long,)
std::unsigned_integral<T>	부호 없는 정수 형식(unsigned + char, short, int, long,)
std::floating_point<T>	부동 소수점 형식(float, double, long double)
std::destructible<T>	소멸자 사용 가능 여부
std::constructible_from<T, ...Args>	std::constructible_from<_Ty, ... _ArgTys> 형식으로 _Ty 객체를 생성할 수 있는지 체크
std::default_initializable<T>	객체 기본 생성자 호출 가능 여부
std::move_constructible<T>	객체 이동 생성자 호출 가능 여부
std::copy_constructible<T>	객체 복사 생성자 호출 가능 여부
std::equality_comparable<T>	객체 상등 비교 가능 여부
std::totally_ordered<T>	전 순서 집합 가능 여부
std::moveable<T>	이동 가능 여부 is_object_v && move_constructible && assignable_from<T&, T> && swappable
std::copyable<T>	복사 가능 여부 copy_constructible && movable && assignable_from<T&, T&>, <T&, const T> <T&, const T&>
std::semiregular<T>	준 정규 형식 여부 copyable && default_initializable
std::regular<T>	정규 형식 여부 semiregular && equality_comparable
std::invocable<F, ...Args>	std::invoke를 호출 할 수 있는지 여부
std::regular_invocable<F, ...Args>	invocable에 상등을 보존하고 함수 인수들을 수정하지 않습니다.
std::predicate<F, T, U>	invocable하며 bool 값을 돌려 줍니다.
std::input_iterator<It>	입력 반복자
std::output_iterator<It, T>	출력 반복자
std::forward_iterator<It>	순방향(전진) 반복자
std::bidirectional_iterator<It>	양방향 반복자
std::random_access_iterator<It>	임의 접근 반복자
std::contiguous_iterator<It>	연속 반복자 연속 반복자를 지원하려면 컨테이너 요소들을 메모리에 연속해서 저장 해야 합니다. (std::array, std::vector, std::string)
std::permutable<It>	요소들이 제자리 순서 변경이 가능함 std::forward_iterator
std::mergeable<It1, It2, Out>	정렬된 순차열들을 병합해서 출력 순차열로 산출 할 수 있음
std::sortable<It>	요소들의 순서를 변경해서 정렬된 순차열을 만들 수 있음

[SonarQube] SonarQube 설치 하기

웅웅이님 — Tue, 22 Mar 2022 21:56:55 +0900

사전 필요 작업

Java JDK SE 11버전을 설치합니다.

윈도우

다운로드

https://www.oracle.com/kr/java/technologies/javase/jdk11-archive-downloads.html

우분투

sudo apt install openjdk-11-jdk-headless

export JAVA_HOME=/usr/lib/jvm/java-1.11.0-openjdk-amd64
# es를 위한 JAVA HOME 설정
export ES_JAVA_HOME=/usr/lib/jvm/java-1.11.0-openjdk-amd64

PostgreSQL 설치

sudo apt-get update
sudo apt-get install postgresql postgresql-contrib

# postgres 계정으로 변환
sudo -i -u postgres

# postreSQL 실행
psql

# 유저 생성
$ CREATE USER sonarqube with PASSWORD 'sonarqube';
$ ALTER ROLE sonarqube WITH createdb;

# 스키마 생성
$ CREATE DATABASE sonarqube owner sonarqube;
# 스키마에 권한 부여
$ GRANT ALL PRIVILEGES ON DATABASE sonarqube TO sonarqube;

설치 방법

SonarQube 버전 : 8.9(LTS)

윈도우 환경

윈도우 설치 방법

소나 큐브를 다운로드 합니다.
- https://www.sonarqube.org/downloads/
다운로드한 파일의 압축을 해제 합니다.

리눅스 환경

// 파일을 다운 받습니다.(LTS)
wget https://binaries.sonarsource.com/Distribution/sonarqube/sonarqube-8.9.7.52159.zip
// 압축을 풀기 위한 작업 
sudo apt-get install unzip
unzip sonarqube-8.9.7.52159.zip

설정 및 실행

주요 폴더 설명

$SONARQUBE-HOME은 SonarQube가 설치된 폴더를 말합니다.

경로	설명
$SONARQUBE-HOME/bin	SonarQube 실행 파일 폴더
$SONARQUBE-HOME/conf	SonarQube 설정 파일 폴더
$SONARQUBE-HOME/data	SonarQube 데이터 파일 폴더 es나 웹의 플러그인 정보의 default 저장 폴더
$HOME_SONARQUBE/log	SonarQube 로그 폴더 sonar.<날짜>.log : sonarqube에 대한 로그 정보 es.log : elasticsearch에 대한 로그 정보 web.log : 웹서버에 대한 로그 정보

설정 하기

$HOME_SONARQUBE/conf 폴더의 sonar.properties 파일을 수정합니다.

# PostgreSQL를 설정합니다. 
# Example for PostgreSQL
sonar.jdbc.username=sonarqube
sonar.jdbc.password=mypassword
sonar.jdbc.url=jdbc:postgresql://localhost/sonarqube

# Elasticsearch 저장소를 설정합니다.
# 기본 값은 $SONARQUBE-HOME/data 입니다.
sonar.path.data=/var/sonarqube/data
sonar.path.temp=/var/sonarqube/temp

# 웹 설정을 변경합니다.
# 기본 포트 값은 9000이고 context paths는 "/"입니다.
sonar.web.host=127.0.0.1
sonar.web.port=9000
sonar.web.context=

실행 하기

$HOME_SONARQUBE/bin/ 에서 os에 맞춰서 실행합니다.

기본으로 실행 하였다면 http://localhost:9000 으로 접속 할 수 있습니다.

기본 접속 정보는 admin/admin 입니다.

유저 관리

admin 계정으로 접속하면 Administration -> Security -> Users를 통해서 유저를 추가할 수 있습니다.

프로젝트 연동

프로젝트는 젠킨스를 통해서 연동되거나 프로젝트 자체로 연동 할 수 있습니다.

참조

https://docs.sonarqube.org/8.9/

[MongoDB] 설치 및 삭제

웅웅이님 — Mon, 8 Mar 2021 18:18:26 +0900

이번 글에서는 MongoDB를 설치하는 방법에 대해서 공유합니다.

현재 최신 버전인 mongoDB 4.4를 설치합니다.

리눅스(ubuntu 18.04)

하단에 있는 mongoDB의 공식 사이트를 설치 방법을 참조하시는 것이 좋습니다.

설치 하기

// ubuntu 18.2 & mongoDB 4.4
 
// mongoDB의 public key를 등록합니다. 
wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | sudo apt-key add -
 
// mongoDB의 4.4를 생성하기 위한 리스트 파일 설정
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu bionic/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.4.list
 
// 로컬 패키지 데이터 베이스 업데이트
sudo apt-get update
 
// 최신버전의 mongoDB 설치
sudo apt-get install -y mongodb-org
 
// 서비스 시작
sudo systemctl start mongod

# mongoDB 종료
mongo localhost/admin -u <유저명> -p <비밀번호>
 
> use admin
 
# localhost로 접속해야 됨
> db.shutdownServer();

삭제 방법

// apt로 설치된 mongoDB 확인
sudo apt list --installed | grep mongo
 
// 제거 ex) sudo apt remove mongodb-server
 
sudo rm -r /var/log/mongodb
sudo rm -r /var/lib/mongodb

참조

https://docs.mongodb.com/manual/tutorial/install-mongodb-on-ubuntu/

공 통

몽고 디비 설정 파일

https://docs.mongodb.com/manual/reference/configuration-options/index.html

몽고 DB의 설정 파일은 YAML 포맷으로 되어 있습니다.

경 로

플랫폼	파일 위치
Linux	/etc/mongod.conf
macOS	/usr/local/etc/mongod.conf
Windows	<install directory>\bin\mongod.cfg

중요 옵션

자주 사용하는 옵션

타입	기본값	설명
net.bindIp	localhost	ip address 정보 ex) 0.0.0.0
net.port	27017 - mongod 27018 - shard member 27019 - config server member	MongoDB의 포트번호
processManagement.fork	false	백그라운드에서 실행하도록 mongod에 데몬 모드를 설정합니다.
processManagement.pidFilePath	경로	mongod의 프로세스 ID를 저장할 경로를 지정합니다.
processManagement.timeZoneInfo	/usr/share/zoneinfo
replication.enableMajorityReadConcern	true	Read Concern은 아래와 같은 타입이 있음 local : 본인의 NODE 확인 majority : 다수의 NODE가 동의
replication.oplogSizeMB	사용 가능한 disk의 5% 공간	replication 작업을 위한 로그 사이즈의 최대 크기 설정 (MB단위)
replication.replSetName		mongod 가 속한 replication 셋트의 이름입니다. replication set에 속한 모든 인스턴스들은 동일한 값을 가집니다.
systemLog.destination	"file" or "syslog"	file : systemLog.path 경로에 파일을 기록합니다. file 옵션을 추천하는 이유는 syslog의 경우 timestamp를 syslog가 생성하기 떄문에 로그가 생성된 시간하고 불일치 할 수 있음(특히 부하가 심한 경우)
systemLog.logRotate	rename	rename : 로그 파일의 이름을 변경합니다. reopen : 일반적인 linux/unix의 동작 방식에 따라 로그파일을 관리합니다. reopen을 사용하는경우 logAppend도 true로 설정해야 함.
systemLog.path	/var/log/mongodb/mongod.log	로그가 기록되는 경로
systemLog.quiet	false	mongos 또는 mongod를 조용한 모드로 실행합니다.
systemLog.syslogFacility	user	syslog에 기록되는 메시지를 설정
systemLog.traceAllExceptions	false	디버깅을 위한 자세한 정보를 출력
systemLog.verbosity	0	로그 상세 수준을 설정합니다. 디버그 메시지를 추가하려면 1 ~ 5 사이 값을 설정해야합니다.

Mongo 계정 추가 방법

// 클라이언트로 접속
mongo
 
// admin으로 변경
> use admin
 
// pbnadmin 계정 추가
> db.createUser({user : "admin", pwd:"12345", roles :['root'], mechanisms : ["SCRAM-SHA-1"]})