C++/문법
덤프버전 :
관련 문서: C언어/문법 
상위 문서: C++ 1. 개요[편집]
C++의 문법을 간략하게 설명하는 문서이다. C언어하고도 중첩되는 요소들이 많으므로 이 문서를 쉽게 이해하기 위해서는 C언어/문법 문서와 비교하여 참조하는 것이 좋다. 하지만 C 관련 문법 + 객체지향 문법만 안다고 해서 C++를 잘 아는건 아니다. 일단 C++11 이후로 추가된 기능이 엄청나게 많기 때문. 템플릿 공부도 많이 해야 한다. 여기에 쓰여있는것들은 핵심만 설명하며 응용을 가르쳐주진 않는다.
###include <iostream>
##int main()
##{
## std::cout << "Hello, world!\n";
## return 0;
##}
##2. 자료형 (Data Types)[편집]
자세한 내용은 C++/문법/자료형 문서를 참고하십시오. 3. 함수[편집]
3.1. 정의[편집]
3.2. 구성[편집]
3.2.1. 평가 지시자[편집]
-
static
해당 함수가 정적 함수임을 나타낸다. 정적 함수는 정적 변수처럼 현재 코드 범위(Scope)에서 항상 같은 이름으로 같은 메모리 위치에 존재한다. 적어도 같은 범위에서는 같은 이름이 같은 함수임을 알 수 있다. 그러므로 C의 소스 구조에서 소스 파일이 아니라 헤더 파일에서 함수와 변수를 정의하기 위해 사용해왔다. 여러 곳에서 중복 삽입될 수 있는 헤더에서는 중복 객체 링킹 때문에 오직 선언만을 사용해야했다. 아니면 구조체 안에 필드 또는 메서드로 정의해야 했다.
staticstaticexportstatic-
inline
해당 함수의 쓰임새 부분이 함수의 코드로 대체될 수 있음을 나타낸다 [1]. 이 키워드가 적절하게 쓰이면 함수 호출 오버헤드를 줄이고, 호출 스택도 아낄 수 있어서 좋다. 심지어 최적화 과정에서 아예 인라인 함수의 코드를 날리고 결과값만 남길 수도 있다. 그렇지만 대부분의 현대 컴파일러는 알아서 인라인 처리를 해주므로 이 지시자의 의의는 더 적극적으로 인라인을 하라는 지시에 가깝다.
-
constexpr
해당 함수가 상수 표현식임을 나타낸다. C++11에서 추가되었다. 상수 표현식, 또는 상수식은 실제 코드가 실행되는 런타임 시점이 아니라 바이너리가 생성되는 컴파일 시점에 실행 결과가 결정될 수 있는 식이다. 아무런 코드 연산의 과정이 컴파일 이후에는 남지 않기 때문이다. 즉 프로그램 이용자의 실행 시점에는 코드 실행 시간이 0이 되도록 최적화된다.
C++20에 와선 동적 메모리 할당 조차 컴파일 시점에 실행될 수 있다. 컴파일러는 이러면 할당 위치만 힙이고 작동은 스택처럼 구현되어 힙의 내용이 컴파일 시점에 결정된다. C++20에서 동적 배열 클래스
C++20에 와선 동적 메모리 할당 조차 컴파일 시점에 실행될 수 있다. 컴파일러는 이러면 할당 위치만 힙이고 작동은 스택처럼 구현되어 힙의 내용이 컴파일 시점에 결정된다. C++20에서 동적 배열 클래스
std::vectorstd::stringconstexprconsteval-
consteval
해당 함수가 상수 표현식이고, 문맥 상으로도 반드시 컴파일 시점에 평가 되어야함을 나타낸다. 보면 알겠지만 맨 처음 도입된
이 지시자의 의의는 컴파일러 전용 함수를 C++에 구현한다는 것에 있다.
constexprconstevalconsteval이 지시자의 의의는 컴파일러 전용 함수를 C++에 구현한다는 것에 있다.
constexprconstevalconsteval3.2.2. 반환 자료형[편집]
사용자가 직접 전체 자료형을 기입하거나
autoauto->autoauto Add(T t, U u) -> decltype(t + u)3.2.3. noexcept[편집]
함수에서 예외를 던지는지 여부를
noexceptnoexceptnoexcept(상수 bool 표현식)std::is_nothrow_*noexcept3.2.4. 매개변수[편집]
3.2.4.1. 값으로 전달[편집]
import <print>;
void increment1(int x)
{
++x;
}
void increment2(volatile int x)
{
++x;
}
void increment3(int x, const int y)
{
x += y;
}
int main()
{
int a = 100;
int b = 500;
increment1(a); // 아무것도 안 함 (1)
increment1(7124820); // (2)
increment2(a); // (3)
increment2(a + b); // (4)
increment3(a, 9058142); // (5)
increment3(a, b); // (6)
std::println("a의 값: {}", a) // 100
std::println("b의 값: {}", b) // 500
return 0;
}
함수의 매개변수로 사용하기 위해 인자를 값으로 호출하는것. 여기서 중요한것은, 값으로 전달하면 해당 인자는 함수의 범위 내에서 원본이 사용되지 않고, 함수의 매개변수로써 복사되어서 사용된다. 이를 정확한 용어로는 부패 (Decay)라고 한다. 예제의 함수들은 모두 인자
abxxab3.2.4.2. 좌측값 참조로 전달[편집]
자세한 내용은 참조에 의한 호출 문서를 참고하십시오. import <iostream>;
void increment (int &x)
{
++x; // 여기서 x는 복사본이 아님.
}
constexpr int* addressof(int& value) noexcept
{
return &value;
}
int main()
{
// (1)
int a = 0;
increment(a); // a의 값 증가
// (2)
const auto& b = addressof(a); // int* const&
increment(*b); // a의 값 증가
// (3)
const int* c = addressof(a);
increment(*c); // 오류! const int&는 수정할 수 없음
std::cout << a; // (3)을 제외하면 2를 출력함
// (4)
int d = 400;
b = addressof(d); // 오류! const& 포인터는 수정할 수 없음
c = addressof(d); // 문제없음
// (5)
const double& value_d = 3.141592368; // 어떤 실체가 없는 리터럴 값이지만 const&에 저장할 수 있음
return 0;
}
매개변수에 좌측값 참조자를 사용하면 인자로 전달된 변수를 그대로 가져온다. 참조형 매개변수는
lvalue&std::addressof상단의 부패를 계속 설명하자면 여기서도 유의할 점이 있다. 불필요한 복사를 막으려면 인자를 참조형으로 받아야 한다. 원래
auto&&&[]autovoid Function(auto value)valueconst&500ULprvaluexvalueconst&const&3.2.4.3. 우측값 참조로 전달[편집]
void Function1(int&& value);
struct Position { float x, y, z; };
constexpr Position Function2_copy(const Position& pos) noexcept
{
return Position{ pos };
}
constexpr Position Function2_move(Position&& pos) noexcept
{
return Position{ std::move(pos) };
// 또는 수동으로 rvalue 변환
return Position{ static_cast<Position&&>(pos) };
}
class Squirrel
{
public:
std::string myName;
Position myPosition;
};
constexpr void Function3_copy(Squirrel& squirrel, const Position& pos) noexcept
{
squirrel.myPosition = pos;
}
constexpr void Function3_move(Squirrel& squirrel, Position&& pos) noexcept
{
squirrel.myPosition = std::move(pos);
// 또는 수동으로 rvalue 변환
squirrel.myPosition = static_cast<Position&&>(pos);
}
void Function3_pos_copy(Squirrel& squirrel, const float& x, const float& y, const float& z);
void Function3_pos_move(Squirrel& squirrel, float&& x, float&& y, float&& z);
C++11에서 새로 도입된 인자 전달 방식이다.
&&&&&&std::movestatic_castrvaluelvalue&const&또한 한번 사용되면 바로 사라질 값이기에 중복해서 사용할 수 없다. 예를 들어 가변 배열인 표준 라이브러리의
std::vectorstd::mutex4. 클래스 (Class)[편집]
">
5. 템플릿 (Template)[편집]
자료형, 함수, 클래스를 모두 읽고 오는 것을 추천한다.
5.1. 변수[편집]
5.2. 함수[편집]
// 매개 변수가 있고 반환값은 없는 함수
template<typename T>
void SetID(const T& obj, unsigned long long id)
{
obj.id = id;
}
// 사용자 정의 noexcept 명세를 사용하는 함수
inline constexpr size_t MySize = 10;
int MyBuffer[MySize]{};
template<size_t Index>
constexpr int& Set(const int& value) noexcept(Index < MySize) // Index가 MySize보다 작으면 오류가 없다.
{
// 그러나 예외를 잡아내는 코드를 생성하지 않는다는 거지, 예외가 발생하지 않도록 하는 건 아니다.
// 여전히 Index가 MySize 이상이면 오류가 발생한다.
// 그냥 noexcept로 지정하면, 메모리 접근 위반이 발생했을때 예외 알림 대신 프로그램이 종료된다.
return MyBuffer[Index] = value;
}
// 후속 반환형을 사용하는 함수
// 제약조건, noexcept 명세, 후속 반환형 사용
template<typename T, size_t Size>
requires std::copyable<T> // <concept>
constexpr auto CreateArray(const T& value)
noexcept(std::is_nothrow_copy_constructible_v<T>) // <type_traits>
-> std::array<T, Size>
{
// <array>
std::array<T, size> result{};
// <ranges>
std::ranges::fill(result, value);
return result; // Return Value Optimization 적용
}
5.2.1. 템플릿 인자 추론[편집]
import <string>;
import <print>;
template<typename T>
void increment1(T x)
{
++x;
}
void increment2(auto x)
{
++x; // 전위 증가 연산자를 사용할 수 없으면 예외 발생
}
template<typename T>
void increment3(T lhs, T rhs)
{
lhs += rhs;
}
template<typename T>
void increment4(T lhs, const T* rhs)
{
lhs += *rhs;
}
void increment5(auto lhs, auto rhs)
{
lhs += rhs;
}
int main()
{
int a = 100;
long long b = 500;
const int c = 900;
int& d = a;
increment1(a); // 아무것도 안 함 (1)
increment1(510942633); // (2)
increment1(b); // (3)
increment1(d); // (4) d는 a의 참조 변수이지만 &가 부패해서 사라진다
increment1('B'); // (5)
increment1("namu"); // 오류! 문자열은 더할 수 없습니다
increment2(a); // (4)
increment2(a + b); // (5) 값에 의한 전달은 prvalue도 전달할 수 있다
increment2('B'); // (6)
increment2("wiki"); // 오류! 문자열은 더할 수 없습니다
increment3(a, 1058142); // (7)
increment3(a, c); // (8) 인자의 const는 매개변수의 auto에 영향을 끼치지 못한다
increment3(a, b); // 오류! 전달된 두 매개변수 T의 자료형이 서로 다릅니다
increment4(a, &c); // (9) 포인터(주소)는 glvalue만이 가질 수 있다. glvalue는 lvalue라서 모든 한정자를 반드시 유지한다
increment4(a, &b); // 오류! 전달된 두 매개변수 T의 자료형이 서로 다릅니다
increment4(a, &d); // 오류! 포인터와 인자의 const 한정자가 일치하지 않습니다
increment5(a, b); // (10)
increment5(d, c); // (11) d는 참조형이지만 auto에서 &가 부패해서 사라진다
increment5(c, d); // (12)
increment5(d, b); // (13)
increment5(std::string{ "Namu" }, std::string{ "Wiki" }); // (14)
std::println("a의 값: {}", a) // 100
std::println("b의 값: {}", b) // 500
std::println("c의 값: {}", c) // 900
std::println("d의 값: {}", d) // 100 (a의 참조형)
return 0;
}
여기서
increment1increment2autoautoauto&const&&&*T&&auto&&5.2.2. 완벽한 매개변수 전달[편집]
import <type_traits>;
void ValueFunction(auto value);
void LvalueFunction(auto& value);
void RvalueFunction(auto&& value);
auto&& Function4_forwarding(auto&& value)
{
// 복사, &, &&, []가 모두 사라짐 (Decay)
// 복사할 수 없는 값이라면 오류 발생함
return value;
// std::move는 lvalue를 보존하지 않기 때문에 문제가 생긴다.
// value가 glvalue
// T&: T&&
// const T&: lvalue는 const T&, xvalue는 const T&&
// value가 rvalue
// T&& - T&&
// const T&& - const T&&
return std::move(value);
}
int main()
{
const long A = 132435;
ValueFunction(A); // value는 long
ValueFunction(std::move(A)); // value는 long
ValueFunction(8000); // 리터럴 value는 int
LvalueFunction(A); // value&는 const long&
LvalueFunction(std::move(A)); // value&는 const long&
LvalueFunction(8000); // 오류! 리터럴은 lvalue에 대입할 수 없음
RvalueFunction(A); // value&&는 const long&
RvalueFunction(std::move(A)); // value&&는 const long&&
RvalueFunction(8000); // 리터럴 value&&는 int&&
}
auto*constvolatile&&&constvolatileconstconstvolatile&&&그래서 사용자가
auto&&const volatileconstvolatileauto&lvalue&&LvalueFunction500int(120648395)const&&&RvalueFunctionrvalueauto&&import <utility>;
template<typename T>
T&& Function5_forwarding_by_template(T&& value) noexcept(noexcept(std::declval<T&&>()))
// 원본 자료형을 유지한채 value의 객체가 생성될 때 예외가 없음을 확인한다
{
// lvalue, xvalue, prvalue 모두가 원래 값 범주(Value Category)를 유지한채, 아무 비용없이 전달된다
// lvalue는 lvalue 그대로 전달된다
// xvalue를 감싸 이름없이 전달한다
// prvalue를 감싸 이름없이 전달한다
return std::forward<T>(value);
}
template<typename T, typename V>
auto&& Function5_modified_forwarding_by_template(V&& value) noexcept(noexcept(std::forward_like<const volatile T>(std::declval<V&&>())))
// 원본 자료형을 바꾼 value의 객체가 생성될 때 예외가 없음을 확인한다
{
// 원래 값 범주를 유지한채로, 다른 자료형으로 바꿔 전달할 수 있다.
return std::forward_like<const volatile T>(value);
}
// C++23부터 사용할 수 있는 Function5_forwarding_by_template과 같은 코드
auto&& Function5_forwarding_by_deduction(auto&& value) noexcept(noexcept(std::declval<T&&>()))
// 원본 자료형 그대로 value의 객체가 생성될 때 예외가 없음을 확인한다
{
// C++23부터 가능한 완벽한 전달 수단
return auto{ value };
// 또는
return auto(value);
}
Position Function6_forwarding_by_copy(const Position& pos) noexcept(std::is_nothrow_copy_constructible<Position>)
{
// pos를 복사해서 전달한다
return pos;
}
Position&& Function6_forwarding_by_move(Position&& pos) noexcept(std::is_nothrow_move_constructible<Position>)
{
// pos를 아무 성능 오버헤드 없이 그대로 전달한다
return std::move(pos);
// 이동 연산에 써도 문제 없다. 그러나 lvalue가 아님을 유의해야 한다
return std::forward<Position>(pos);
// 경고! 이 경우 복사가 되어 참조 Dangling이 일어난다
return pos;
}
매개변수로 실체화하기 전, 인자에서는
&&&&&&&&&&&static_cast(T&) T&&static_cast(T&) const T&&autodecltype(auto)const auto&auto&&5.2.3. 사용 예제[편집]
">tuple1std::tuple<long, unsigned long long, bool, bool, Squirrel, Squirrel, unsigned>tuple2std::tuple<const long&, unsigned long long&&, bool&, bool&, Squirrel&, const Squirrel&, const unsigned&&>5.3. 클래스[편집]
5.3.1. 템플릿 필드[편집]
5.3.2. 템플릿 메서드[편집]
5.3.3. Deducing this[편집]
6. 이름공간 (Namespace)[편집]
namespace /*식별자*/
{
...;
}
이름공간, 또는 네임스페이스는 식별자 사이의 이름 충돌을 막기 위한 장치이다. 이름공간은 각각 분리된 프로그램처럼 존재하며 다른 이름공간끼리는 별도의 지시자없이는 참조할 수 없다 [5]. 당연히 지시자 없이는 다른 이름공간의 식별자를 참조할 수 없다. 프로젝트가 일정 규모 이상 커지거나, 외부 라이브러리를 사용하는 경우 이름이 같은 함수, 상수, 클래스[6] 등이 발생할 가능성이 커진다.
예를 들어 비슷한 용도의 반복적인 기저 코드 작성(Boilerplate)이 프로젝트에서 반복되다 보면 단어란 단어는 다 소모하고 비슷한 유틸리티 함수가 늘어난다. 이때 다른 라이브러리 사이에 같은 이름의 객체가 있으면 컴파일러는 이를 구분할 수 없다. 차라리 모호하다고 컴파일 오류를 내거나 런타임 오류라도 나면 다행이지만, 그렇지 않고 정상작동하는 것처럼 보이는 코드가 되면 예측할 수 없는 동작을 할 것이다. C언어에서 가장 큰 문제 중 하나가 프로젝트가 커질수록 식별자의 명칭이 겹칠 위험이 커지는 것이였다. C++에서 도입된 이름 공간은 큰 규모의 프로그램 개발에서 객체의 명명 문제를 대부분 해결해준다 [7].
6.1. 용법[편집]
import <print>;
import <string>;
namespace Namu
{
class MyClass
{
public:
void MyPrint() const noexcept
{
std::println(myCaption);
}
private:
std::string myCaption = "나무위키";
};
}
namespace Wiki
{
class MyClass
{
public:
void MyPrint() const noexcept
{
std::println(myCaption);
}
private:
std::string myCaption = "NamuWiki";
};
}
int main()
{
Namu::MyClass class1;
Wiki::MyClass class2;
class1.MyPrint();
class2.MyPrint();
return 0;
}
이 소스 코드의 콘솔에서의 실행 결과는 다음과 같다.
첫번째 줄에는 '나무위키'가 출력되고 두번째 줄에는 'NamuWiki'가 출력된다.
6.2. using namespace[편집]
usingusingusing [네임스페이스 이름]::[네임스페이스 멤버 이름];using [네임스페이스 x]::[클래스 y];x::y [인스턴스 이름];y [인스턴스 이름]using [네임스페이스 x]::[멤버 함수 a];x::a(...);a(...);using namespace [네임스페이스 이름][네임스페이스 이름]::[클래스 이름] [인스턴스 이름];[클래스 이름] [인스턴스 이름];using namespace [네임스페이스 x]using [네임스페이스 x]::[클래스 y];using [네임스페이스 x]::[멤버 함수 a];x::y [인스턴스 이름];y [인스턴스 이름]x::a(...);a(...);가령 C++에서 가장 많이 선언되는
using namespace std;stdstdstd::coutcout항목 5의 예제에서
#includeusing namespacenamu;mainnamuMyClassclass1namu::MyClass class1;MyClass class1;using#includeusingusingusing6.3. Global Namespace[편집]
import <print>;
import <string>;
class Namu
{
public:
void print() const noexcept
{
std::println(myCaption);
}
private:
std::string myCaption = "Namu";
};
class Wiki
{
public:
void print() const noexcept
{
std::println(myCaption);
}
private:
std::string myCaption = "Wiki";
};
namespace Full
{
using ::Wiki; // ::로 사용 가능함
using ::Namu;
// 또는
using Namu;
// 또는
using Namu = ::Namu;
}
int main(void)
{
Namu class1;
::Wiki class2;
class1.print();
class2.print();
return 0;
}
전역적 이름공간 (Global Namespace)
이름공간이 명시 되어있지 않을 때는 전역적 이름공간을 사용하게 된다. C언어도 기본적으로 전역적 이름공간을 사용한다. 이름 공간의 이름을 적지 않고
이름공간이 명시 되어있지 않을 때는 전역적 이름공간을 사용하게 된다. C언어도 기본적으로 전역적 이름공간을 사용한다. 이름 공간의 이름을 적지 않고
::그러나 전역 네임스페이스의 사용은 일반적으로 권장되지 않는다. 이름공간의 목적은 다른 역할을 하지만 중복되는 이름을 구분하기 위해 만들어 진 것인데 전역 네임스페이스는 그것을 무력화시키며 헤더에 전역 네임스페이스를 사용하게 되면 그 헤더를 삽입하는 소스 코드도 영향을 받기 때문이다. 설령 모듈이라도 이름의 중복은 피할 수 없는 문제다. 그렇기에 스코프 안에서만 사용하는 것이 좋다.
6.4. inline[편집]
// 중접 이름공간 선언
namespace NamuWiki::Documents::ProgrammingLanguage::inline FromEnhaWiki
{
class Assemybly;
class C;
class Erlang;
class Cpp;
class Java
class Python;
class JavaScript;
class Csharp;
class Go;
class Swift;
class Rust;
}
namespace House::LoungeRoom::Furnitures
{
inline namespace Y2019
{
class Television
{
public:
std::string hwVender = "Samsung";
};
class Fan
{
public:
std::string hwVender = "Dyson";
};
class Couch;
class Chair;
class LargeTable;
}
inline namespace Y2021
{
class Television
{
public:
std::string hwVender = "Samsung";
};
class Fan // Y2019::Fan 클래스를 덮어쓴다.
{
public:
std::string hwVender = "LG";
};
class AirConditioner;
class MiniBar;
}
inline namespace Y2023
{
class Television // Y2021::Television 클래스를 덮어쓴다.
{
public:
std::string hwVender = "LG";
};
}
}
인라인 이름공간을 사용하면 선언한 이름공간의 내용물을 상위 이름공간에서도 바로 사용할 수 있다. 사실 인라인 이름공간의 원리는 상위 이름공간에 내용을 먼저 집어넣고, 인라인 이름공간 안에서
using6.4.1. Unnamed Namespace[편집]
namespace CPUVenders
{
class Intel;
class AMD;
class [[deprecated]] VIA;
}
namespace
{
class Nvidia;
// CPUVenders::AMD, CPUVenders::Intel과 ::AMD, ::Intel은 다른 존재다.
// 같은 객체로 취급하려면 using CPUVenders::...를 사용해야만 한다.
class AMD;
class Intel;
}
namespace HardwareVenders
{
namespace
{
GigaByte,
Asus,
}
// using (익명)::GigaByte;
// using (익명)::Asus;
namespace CPUVenders = ::CPUVenders;
namespace GPUVenders
{
using ::Nvidia;
using ::AMD;
using ::Intel;
}
}
익명 이름공간은 이름공간을 선언할 때 식별자를 지정하지 않으면 된다. 이 경우 익명 이름공간이 선언된 스코프에서
using namespace (익명 이름공간);6.5. 인자 의존성 탐색[편집]
인자 의존성 탐색 (Argument Dependency Lookup)
7. 언어 연결성 (Language Linkage)[편집]
Language Linkage
7.1. 내부 연결[편집]
내부 연결 (Internal Linkage)
다른 프로그래밍 언어가 그렇듯, C++에는 스코프(Scope)라는 개념이 있다. 그 동안 프로그래밍에서 스코프라는 것이 정확히 뭔지 모르고 사용했을 것이다. C++에서는 이 조차 정확한 정의를 내리고 시작한다. C++의 스코프는 컴파일 과정에서 나타나는 코드 번역의 단위다. 쉽게 말해 식별자와 스택이 공유되는 문맥(Context)이다. 예를 들어 이름공간, 클래스의 메서드, 함수 등이 있다. 내부 연결은 문맥 안에서 선언된 식별자는 문맥 밖에서는 사용할 수 없는 상태를 말한다. 내부 연결은 밖에선 보이지 않기 때문에 당연히 이름의 중복, 모호성 문제가 발생하지 않는다. 가령 함수의 지역 변수와 매개변수, 전역 정적 변수와 함수, 그리고 모듈에서 내보내지 않은 식별자 등이 있다.
7.2. 외부 연결[편집]
외부 연결 (External Linkage)
외부에서 보이는 상태, 즉 인터페이스를 말한다. 현재 스코프 뿐만 아니라 다른 문맥에서 접근할 수 있다. 심지어 언어나 프로그램에서도 접근할 수 있다. 외부 연결이 지정된 객체는 선언만 있어도 된다. 이름 붙여지지 않은 이름공간(Unnamed Namespace)이 아닌 식별자가 있는 이름공간 안에 있는 객체들에는 외부 연결이 적용된다.
7.3. 모듈 연결[편집]
모듈 연결 (Module Linkage)
C++20의 모듈은
privateexport8. 저장소 지속요건 (Storage Duration)[편집]
Storage Duration
저장소 지속요건은 운영체제 메모리 모델과 깊은 연관이 있다. C++의 객체가 어떤 메모리에, 어느 위치에 할당되어서, 얼마나 오래 살아남는지를 정의한다.
8.1. static[편집]
class Device
{};
// 이름없는 이름공간 안에 있으면 무조건 내부 연결이 된다.
// 설령 extern 이라도.
namespace
{
namespace InternalLinkage
{
class MyTablet : public ::Device
{
public:
static std::string hwVender;
static std::string hwIdentifier;
};
class MyPhone : public ::Device
{
public:
// constinit 사용
static inline constinit std::string hwVender = "Google";
static inline constinit std::string hwIdentifier = "Pixel 5";
protected:
std::string callNumber;
std::size_t callCounts;
std::string IMEI;
};
}
class MyDesktop : public Device
{
public:
static std::string hwVender;
static std::string hwIdentifier;
};
// extern이지만 내부 연결 함수
extern std::string_view GetMyDeviceID(std::string_view simple_name) noexcept;
}
// 구현 내용이 없으면 링크 오류가 발생한다.
// 그러나 내부 연결 객체는 현재 이름공간에 유일한 존재로 남으므로 식별자의 중복 선언 문제가 발생하지 않는다.
static std::string_view GetMyDeviceVender(std::string_view simple_namev) noexcept
{
if (simple_name == "Desktop")
{
return MyDesktop::hwVender;
}
else if (simple_name == "Phone")
{
return InternalLinkage::MyPhone::hwVender;
}
else if (simple_name == "Tablet")
{
return InternalLinkage::MyTablet::hwVender;
}
else
{
return "No Device";
}
}
// 이름 공간과 클래스 내의 구현 내용은 스코프 밖에, 그리고 헤더라면 별도의 소스 파일에 작성해야 한다.
std::string InternalLinkage::MyTablet::hwVender = "Apple";
std::string InternalLinkage::MyTablet::hwIdentifier = "IPad 6th Gen";
std::string MyDesktop::hwVender = "TG삼보";
std::string MyDesktop::hwVender = "TG-DT281-GA51B-011";
C++에서 내부 연결을 표현할 때는
staticstaticstaticMyPhone::callNumber0x00000016callNumberMyPhone내부 연결을 가진 객체는 반드시 구현 내용을 갖고 있어야만 한다. 즉 인라인(inline)이여야만 한다. 만약 내부 연결 객체를 만들 때 값을 전달하지 않으면 어떻게 될까? 변수라면 기본값이 할당 되지만 함수는 선언만 할 수 없다. 내부 연결을 가진 클래스 인스턴스에서 별도로 생성자를 호출하지 않으면 인자가 없는 기본 생성자를 호출한다 [10]. 이때 생성한 인스턴스의 클래스에 기본 생성자가 없으면 내부 연결을 가질 수 없다.
staticstaticinline constexprstatic inline constexprconstinit8.2. extern[편집]
정적인 외부 연결
externstaticexternextern "C"extern "C++"extern "C++"extern "C++"extern "C"extern "C" { ...; }8.3. thread_local[편집]
import <cstdlib>;
import <vector>;
import <thread>;
import <chrono>;
import <print>;
// 전역 스코프에 선언되어 있지만, 실제로는 스레드 단위 지역 변수다.
thread_local size_t threadID;
thread_local size_t threadCount = 0;
void Watcher(size_t id)
{
// 보이지 않는 threadID, threadCount 지역 변수가 선언되어 있다.
threadID = id;
using namespace std::chrono_literals;
while (true)
{
if (::rand() % 10 == 0)
{
std::println("스레드 ID {}에서 {}번째 보고", threadID, ++threadCount);
}
std::this_thread::sleep_for(1s);
}
}
int main()
{
std::vector<std::jthread> myThreads{};
myThreads.reserve(4);
for (size_t i = 0; i < 4; ++i)
{
myThreads.emplace_back(Watcher, i);
}
while (true)
{
std::this_thread::yield();
}
return 0;
}
변수 선언에 사용할 수 있다. 참고로 내부나 외부 연결에 관여하지는 않고, 상단 키워드들과 조합해서 쓸 수 있다. 전역 변수로 선언하면 이 순간부터 프로그램에서 사용한 모든 스레드에도 해당 변수가 선언되게 된다.
8.4. mutable[편집]
import <atomic>;
import <vector>;
import <thread>;
import <print>;
class SpinLock
{
public:
constexpr SpinLock() noexcept = default;
~SpinLock() noexcept = default;
// const 메서드이지만 myState를 수정하고 있다.
void Lock(std::memory_order model = std::memory_order::memory_order_acquire) const volatile noexcept
{
while (!TryLock(model));
}
bool TryLock(std::memory_order model = std::memory_order::memory_order_relaxed) const volatile noexcept
{
return !mySwitch.test_and_set(model);
}
void Unlock(std::memory_order model = std::memory_order::memory_order_release) const volatile noexcept
{
mySwitch.clear(model);
}
[[nodiscard]] bool IsLocked() const noexcept
{
return mySwitch.test(std::memory_order::memory_order_relaxed);
}
SpinLock(const SpinLock&) = delete;
SpinLock& operator=(const SpinLock&) = delete;
private:
mutable volatile std::atomic_flag mySwitch;
};
// const여도 아무 문제 없다.
const SpinLock globalLock{};
size_t globalCounter = 0;
void Incrementor(size_t max) noexcept
{
for (size_t i = 0; i < max; ++i)
{
globalLock.Lock();
globalCounter++;
globalLock.Unlock();
}
}
int main()
{
constexpr size_t target = 1000'0000'0000'0000;
constexpr size_t thrd_count = 10;
constexpr size_t thrd_workout = target / thrd_count;
std::vector<std::thread> myThreads{};
myThreads.reserve(thrd_count);
for (size_t i = 0; i < thrd_count; ++i)
{
myThreads.emplace(Incrementor, thrd_workout);
}
for (auto& th : myThreads)
{
th.join();
}
std::println("결과: {}", globalCounter); // 1000000000000000
return 0;
}
클래스의 필드에 사용할 수 있다.
constconstconst9. 특성 (Attribute)[편집]
이 문서의 내용 중 전체 또는 일부는 2023-10-21 19:45:17에 나무위키 C++/문법 문서에서 가져왔습니다.[C++11] [C++20] [1] 이를 인라이닝(Inlining)이라고 한다[2] 함수형 언어에서 함수와 정확히 같다[3] constexpr 변수는 무조건 상수이며, 컴파일 시점에 평가된다[4] 운영체제 플랫폼 구분 등[5] 이를 코드 범위(Scope)가 다르다고 한다[6] 이를 통틀어 객체라고 칭한다[7] 많은 객체 지향 언어가 그렇듯 C++에서도 이름이 같은 두 클래스가 속한 이름공간이 다르면 공존할 수 있다[8] 네임스페이스 멤버로는 클래스, 클래스 멤버 함수가 있다.[9] 참고로 모듈에서 내보내진 객체들은 외부 연결로 취급된다.[10] 여기서 기본 생성자는
default