[C++]표준 라이브러리 데이터(Standard Library DataType)

Philip Sung·2023년 1월 3일
0

[C++]

목록 보기
1/4
post-thumbnail

01 개요

본 문서에서는 C++에서 사용하는 표준 라이브러리 중 자주 사용되는 데이터 타입에 해당하는 내용을 다룬다.

최종수정일 : 2023.01.25

vector string set multiset unordered_set map multimap unordered_map




02 <string>




03 <vector>

03.01 구조

`
//using vector
#include <vector>

template <class Type, class Allocator = allocator<Type>>
class vector
`

03.02 초기화

vector<type> objectname[ (containersize, [initialvalue] ) ];

아래 항목은 생략 가능하다.

containersize
입력된 매개변수 만큼의 빈 공간을 미리 할당받은 컨테이너를 생성한다.

initialvalue
사전에 할당받은 컨테이너의 초기값을 해당 매개변수의 값으로 초기화한다.

03.04 Method

03.04.00 push_back

void push_back(const T& value);
void push_back(T&& value);




04 <set> : set, multiset

값이 곧 키로써 사용된다.
원소를 정렬한다.
삽입된 값은 변경될 수는 없고, 추가하거나 제거될 수 있다.
각 값은 <set>에서는 유일해야 하며, <multiset>에서는 중복될 수 있다.

04.01 구조

`
//using set and multiset
#include <set>

template < 
	class T,					//{set|multiset}::key_type/value_type
	class Compare = less<T>,	//{set|multiset}::key_compare/value_compare
	class Alloc = allocator<T>	//{set|multiset}::allocator_type
>class set;	//or class multiset;
`

04.02 초기화

set<type> objectname = { value1, ... }
multiset<type> objectname = { value1, ... }




05 <unordered_set>

05.01 구조

`
//using unordered_set
#include <unordered_set>

template < class Key,				// unordered_set::key_type/value_type
	class Hash = hash<Key>,			// unordered_set::hasher
    class Pred = equal_to<Key>,		// unordered_set::key_equal
    class Alloc = allocator<Key>	// unordered_set::allocator_type
> class unordered_set;
`

05.02 초기화

unordered_set<type> objectname = { value1, ... }




06 <map> : map, multimap

하나의 컨테이너 내에서 각각의 키는 유일하다.
각 데이터쌍은 키 값에 의해 (*.kor)Strict weak ordering에 따라 정렬되어 저장된다.
각 데이터값에는 인덱스 대신 키값을 이용해 접근해야 한다.
<map> 컨테이너는 <unordered_map> 컨테이너에 비해 일반적으로 느린 성능을 가진다.

06.01 구조

`
//using map, multimap
#include <map>

template <
	class Key,									// map::key_type
	class T,									// map::mapped_type
	class Compare = less<Key>,					// map::key_compare
	class Alloc = allocator<pair<const Key,T>>	// map::allocator_type
>class map;			//or class multimap;

//member type
typedef pair<const Key, T> value_type;
`

06.02 초기화

map<keytype, valuetype> objectname = { {key1, value1}, ... }




07 <unordered_map>

키를 통해 값에 효율적으로 접근하기 위해 해시값을 이용한다.

07.01 구조

`
//using unordered_map
#include <unordered_map>

template < 
	class Key,										// unordered_map::key_type
	class T,										// unordered_map::mapped_type
	class Hash = hash<Key>, 						// unordered_map::hasher
	class Pred = equal_to<Key>,						// unordered_map::key_equal
	class Alloc = allocator< pair<const Key,T> >	// unordered_map::allocator_type
>class unordered_map;
`

07.02 초기화

unordered_map<keytype, valuetype> objectname = { {key1, value1}, ... }




08 <stringstream>

08.01 구조

`
#include <sstream>
template <
	class charT,						// basic_istringstream::char_type
	class traits = char_traits<charT>,	// basic_istringstream::traits_type
	class Alloc = allocator<charT>,		// basic_istringstream::allocator_type
>class basic_istringstream;
//same structure with basic_ostringstream, basic_stringstream, basic_stringbuf

typedef basic_istringstream<char> istringstream;
typedef basic_ostringstream<char> ostringstream;
typedef basic_stringstream<char> stringstream;
typedef basic_stringbuf<char> stringbuf;

//typename of <w_char> also defined in header file
`

08.02 멤버변수

memberdefinition
char_typechar
traits_typechar_traits<char>
allocator_typeallocator<char>
int_typeint
pos_typestreampos
off_typestreamoff

*Inherited Members : istream, ostream, ios_base

08.03 멤버함수

memberdefinition
(constructor)Construct object (public member function)
strGet/set content (public member function)
operator=Move assignment (public member function)
swapSwap internals (public member function)
swap(non-member function overloads)Swap string streams (function template)

*Inherited Members : istream, ostream, ios, ios_base




09 <queue> : queue, priority_queue

앞에서 들어가고 뒤로나오는

09.01 구조

`
//using queue, priority_queue
#include <queue>

template <class T, class Container = deque<T> > class queue;

//priority_queue
template <
	class T,
	class Container = vector<T>, 
	class Compare = less<typename Container::value_type>
>class priority_queue;
`
profile
Philip Sung

0개의 댓글