C++ 유용한 문법

[C++] 유용한 문법

 

casting

to_string()	문자열로
stoi()	string to int
stoll()	string to long long
stod()	string to double
stof()	string to float
stob()	string to bool
c_str()	char*로 변환
atoi()	char* > int

string

생성

string str;	빈 문자열 생성
string str = "abcdef";	"abcdef" 문자열
string str("abcdef");	"abcdef" 문자열
string str2(str)	str을 복사한 str2문자열
char s[ ] = {'a', 'b', 'c', 'd', 'e', 'f'}; string str(s);	char의 문자열과 호환
string *str = new string("abcdef");	new를 이용한 동적할당

 

입출력

cin >> str;	공백 이전까지의 문자열을 입력받는다.
getline(cin, str);	개행("\n") 이전까지의 문자열을 입력받는다. (한줄)
getline(cin, str, 'a')	'a'문자 이전까지의 문자열을 입력받는다.
cout << str	문자열을 출력한다.

string str;
getline(cin, str);
cout << "str : " << str << '\n';
getline(cin, str, 'd');
cout << "str : " << str << '\n';
cin >> str; 
cout << "str : " << str << '\n';

 

연산자

- 문자열 비교 (<, >, ==) : 두 문자열의 사전 순서를 비교, 또는 동일 여부를 확인할 수 있다. 
- 문자열 연결 (+) : 두 문자열을 이어주는 역할을 한다. 

string str1 = "abcdef";
string str2 = "bbbbbb";
string str3 = "aaaa";
string str4 = "abcdef";
cout << (str1 < str2) << ' ' << (str1 < str3) << ' ' << (str1 == str4);
//1 : true , 0 : false

str1 += "A";
cout << str1 << '\n';
str1 = str1 + str2;
cout << str1 << '\n';

 

유용한 string 멤버 함수

▶ string의 특정 원소 접근

str.at(index)	index 위치의 문자 반환. 유효한 범위인지 체크 O
str[index]	index 위치의 문자 반환. 유효한 범위인지 체크 X. 따라서 at 함수보다 접근이 빠름
str.front()	문자열의 가장 앞 문자 반환
str.back()	문자열의 가장 뒤 문자 반환

#include<iostream>
#include<string>

using namespace std;

int main(void) {
    string str = "abcdefgh";
    cout << str.at(2) << '\n';
    cout << str[4] << '\n';
    cout << str.front() << '\n';
    cout << str.back() << '\n';
}​

▶ string의 크기

str.length()	문자열 길이 반환
str.size()	문자열 길이 반환 (length와 동일)
str.capacity()	문자열이 사용중인 메모리 크기 반환
str.resize(n)	string을 n의 크기로 만듦. 기존의 문자열 길이보다 n이 작다면 남은 부분은 삭제하고, n이 크다면 빈공간으로 채움
str.resize(n, 'a')	n이 string의 길이보다 더 크다면, 빈 공간을 'a'로 채움
str.shrink_to_fit()	string의 capacity가 실제 사용하는 메모리보다 큰 경우 낭비되는 메모리가 없도록 메모리를 줄여줌
str.reserve(n)	size = n만큼의 메모리를 미리 할당해줌
str.empty()	str이 빈 문자열인지 확인

#include<iostream>
#include<string>

using namespace std;

int main(void) {
    string str = "abcdefgh";
    cout << str.length() << '\n';
    cout << str.size() << '\n';
    cout << str.capacity() << '\n';
    str.resize(6); cout << str << '\n';
    str.resize(8, 'a'); cout << str << '\n';
    str.reserve(20); cout << str.capacity() << '\n';
    str.shrink_to_fit(); cout << str.capacity() << '\n';
    cout << str.empty() << '\n';
}

▶ string에 삽입, 추가, 삭제

str.append(str2)	str 뒤에 str2 문자열을 이어 붙여줌 ('+' 와 같은 역할)
str.append(str2, n, m)	str 뒤에 'str2의 n index부터 m개의 문자'를 이어 붙여줌
str.append(n, 'a')	str 뒤에 n개의 'a'를 이어 붙여줌
str.insert(n, str2)	n번째 index 앞에 str2 문자열을 삽입함.
str.replace(n, k, str2)	n번째 index부터 k개의 문자를 str2로 대체함
str.clear()	저장된 문자열을 모두 지움
str.erase(n, m)	n번째 index부터 m개의 문자를 지움
str.erase(n, m) (iterator)	n~m index의 문자열을 지움 (n과 m은 iterator)
str.erase()	clear와 같은 동작
str.push_back(c)	str의 맨 뒤에 c 문자를 붙여줌
str.pop_back()	str의 맨 뒤의 문자를 제거
str.assign(str2)	str에 str2 문자열을 할당. (변수 정의와 동일)

#include<iostream>
#include<string>

using namespace std;

int main(void) {
    string str = "apple";
    string str2 = "banana";
    str.append(str2);            cout << str << '\n';
    str.append(str2, 1, 3);      cout << str << '\n';
    str.append(3, 'k');          cout << str << '\n';
    str.clear();                 cout << str << '\n';
    str.assign("apple");         cout << str << '\n';
    str.insert(2, str2);         cout << str << '\n';
    str.replace(3, 3, "ttt");    cout << str << '\n';
    str.erase(0, 2);             cout << str << '\n';
    str.erase();                 cout << str << '\n';
    str.push_back('a');          cout << str << '\n';
    str.push_back('b');          cout << str << '\n';
    str.pop_back();              cout << str << '\n';
}​

▶ 기타 유용한 string 멤버 함수

str.find("abcd")	"abcd"가 str에 포함되어있는지를 확인. 찾으면 해당 부분의 첫번째 index를 반환
str.find("abcd", n)	n번째 index부터 "abcd"를 find
str.substr()	str 전체를 반환
str.substr(n)	str의 n번째 index부터 끝까지의 문자를 부분문자열로 반환
str.substr(n, k)	str의 n번째 index부터 k개의 문자를 부분문자열로 반환
str.compare(str2)	str과 str2가 같은지를 비교. 같다면 0, str<str2 인 경우 음수, str>str2 인 경우 양수를 반환
swap(str1, str2)	str1과 str2를 바꿔줌. reference를 교환하는 방식
isdigit(c)	c 문자가 숫자이면 true, 아니면 false를 반환
isalpha(c)	c 문자가 영어이면 true, 아니면 false를 반환
toupper(c)	c 문자를 대문자로 변환
tolower(c)	c 문자를 소문자로 변환

#include<iostream>
#include<string>

using namespace std;

int main(void) {
    string str = "apple";
    string str2 = "banana";
    cout << str.find("ppl") << '\n';
    cout << str.find("appl", 0) << '\n';
    cout << str.find("appl", 1) << '\n';
    cout << str.substr() << '\n';
    cout << str.substr(2) << '\n';
    cout << str.substr(1, 3) << '\n';
    cout << str.compare(str2) << '\n';
    swap(str, str2);                     cout << str << ' ' << str2 << '\n';
    cout << isdigit(str[0]) << '\n';
    cout << isalpha(str[0]) << '\n';
    toupper(str[0]);                     cout << str << '\n';
    tolower(str[0]);                     cout << str << '\n';
}

 

Iterator

생성 및 초기화

vector<int>::iterator iter;	vector 형 iterator
list<int>::iterator iter;	list 형 iterator
set<int>::iterator iter;	set 형 iterator
multiset<int>::iterator iter;	multiset 형 iterator
map<int, string>::iterator iter	map 형 iterator
multimap<int, int>::iterator iter;	multimap 형 iterator

// Vector
vector<int> container;
vector<int>::const_iterator itr;
  itr = container.begin();
  while (itr != container.end())
  {
    cout << *itr << ' ';
    ++itr;
  }
for (auto itr = container.begin(); itr != container.end(); ++itr)
    cout << *itr << ' ';


// list
list<int> container;
for (auto itr = container.begin(); itr != container.end(); ++itr)
    cout << *itr << ' ';
    
    
// set
set<int> container;
for (auto itr = container.begin(); itr != container.end(); ++itr)
      cout << *itr << ' ';
      
// map
 map<int, char> container;
for (auto itr = container.begin(); itr != container.end(); ++itr)
      cout << itr->first << ' ' << itr->second << '\n';
for (auto& e : container)
      cout << e.first << ' ' << e.second << '\n';

itorator 메서드

iter
iter++	앞으로
iter--	뒤로
iter1 == iter2	비교
iter1 != iter2	비교
begin(객체)	객체의 시작 주소를 가지는 iterator 객체를 리턴한다.
end(객체)	객체의 끝 주소를 가지는 iterator 객체를 리턴한다.

 

Vector

초기화

vector<자료형> 변수명	백터 생성
vector<자료형> 변수명(숫자)	숫자만큼 백터 생성 후 0으로 초기화
vector<자료형> 변수명 = { 변수1, 변수2, 변수3... }	백터 생성 후 오른쪽 변수 값으로 초기화
vector<자료형> 변수명[] = {, }	백터 배열(2차원 백터)선언 및 초기화(열은 고정, 행은 가변)
vector<vector<자료형>> 변수명	2차원 백터 생성(열과 행 모두 가변)
vector<자료형>변수명.assign(범위, 초기화할 값)	백터의 범위 내에서 해당 값으로 초기화

vector<int> v;        //int형 백터 생성
vector<int>v(4);    //int형 백터 생성 후 크기를 4로 할당(모든 백터요소 0으로 초기화)
vector<int>v = { 1, 2, 3};        //int형 백터 생성 후 1, 2, 3 으로 초기화
vector<int>v[] = {{ 1, 2}, {3, 4}};        //int형 백터 배열 생성(행은 가변이지만 열은 고정)
vector<vector<int>> v;        //2차원 백터 생성(행과 열 모두 가변)
vector<int> v = { 1, 2, 3, 4, 5};        //백터 범위를 5로 지정하고 정수 10으로 초기화
v.assign(5, 10);    //output : 10 10 10 10 10

Iterators

v.begin()	백터 시작점의 주소 값 반환
v.end()	백터 (끝부분 + 1) 주소값 반환
v.rbegin() (revers begin)	백터의 끝 지점을 시작점으로 반환
v.rend() (revers end)	백터의 (시작 + 1) 지점을 끝 부분으로 반환

    vector<int>::iterator itor = v.begin();

    for (; itor != v.end(); itor++)
        cout << *itor << endl;        //output : 1 2 3 4

    vector<int>::reverse_iterator itor2 = v.rbegin();

    for (; itor2 != v.rend(); itor2++)
        cout << *itor2 << endl;        //output : 4 3 2 1

Vector Element access(백터의 요소 접근)

v.at(i)	백터의 i번째 요소 접근 (범위 검사함(예외처리)
v.[i] (operator [])	백터의 i번째 요소 접근 (범위 검사 안함)
v.front()	백터의 첫번째 요소 접근
v.back()	백터의 마지막 요소 접근

vector<int> v = { 1, 2, 3, 4};

cout << v.front() << endl;        //output : 1
cout << v.back() << endl;        //output : 4
cout << v.at(1) << endl;        //output : 2
cout << v[2] << endl;            //output : 3

Vector에 요소 삽입

v.push_back()	백터의 마지막 부분에 새로운 요소 추가
v.pop_back()	백터의 마지막 부분 제거
v.insert(삽입할 위치의 주소 값, 변수 값)	사용자가 원하는 위치에 요소 삽입
v.emplace(삽입할 위치의 주소 값, 변수 값)	사용자가 원하는 위치에 요소 삽입(move로 인해 복사생성자 X)
v.emplace_back()	백터의 마지막 부분에 새로운 요소 추가(move로 인해 복사생성자 X)
v.erase(삭제할 위치) or v.erase(시작위치, 끝위치)	사용자가 원하는 index값의 요소를 지운다.
v.clear()	백터의 모든 요소를 지운다.(return size = 0)
v.resize(수정 값)	백터의 사이즈를 조정한다.(범위 초과시 0으로 초기화)
v.swap(백터 변수)	백터와 백터를 스왑한다.

#include <vector>

int main(){
    vector<int> v;

    v.push_back(10);
    v.push_back(20);        //v = { 10, 20 }

    v.inset(v.begin() + 1, 100);     // v = { 10, 100, 20 }

    v.pop_back();        // v = { 10, 100 }

    v.emplace_back(1); //v = { 10, 100, 1 }
    v.emplace_back(2);    //v = { 10, 100, 1, 2 }
    v.emplace(v.begin() + 2, -50);    //v = { 1, 100, -50, 1, 2 }

    v.erase(v.begin() + 1); // v = { 1, -50, 1, 2 }
    v.resize(6);    // v = { 1, -50, 1, 2, 0, 0 }
    v.clear();    // v = empty()     
}

Vector Capacity(백터 용량)

v.empty()	백터가 빈공간이면 true, 값이 있다면 false
v.size()	백터의 크기 반환
v.capacity()	heap에 할당된 백터의 실제크기(최대크기) 반환
v.max_size()	백터가 system에서 만들어 질 수 있는 최대 크기 반환
v.reserve(숫자)	백터의 크기 설정
v.shrink_to_fit()	capacity의 크기를 백터의 실제 크기에 맞춤

vector<int>v = { 1, 2, 3, 4 };

cout << v.size() << endl;    //output : 4
cout << v.capacity() << endl; //output : 10 (컴파일 환경에 따라 달라질 수 있음)

v.reserve(6);
cout << v.capacity() << endl; //output : 6
cout << v.max_size() << endl; //output : 1073741823(시스템 성능에 따라 달라질 수 있음)

v.shrink_to_fit();
cout << v.capacity() << endl; //output : 4

cout << v.empty() << endl; //output : false
v.clear();
cout << v.empty() << endl; //output : true​

 

List

생성 및 초기화

list<Type> name;	list 기본 생성
list<Type> name(N);	N개 만큼 default 값으로 채워진 list
list<Type> name(N, value);	N개 만큼 value로 채워진 list
list<Type> name {value, value ....};	value로 채워진 list

list<int> lists; 
list<int> lists(3);		// 0, 0, 0
list<int> lists(4, 3)	// 3, 3, 3, 3
list<int> lists {1, 2, 3, 4}	// 1, 2, 3, 4

 

List Access (리스트 접근)

lists.front()	첫 번째 원소의 참조를 리턴
lists.back()	마지막 원소의 참조를 리턴

 

List Capacity (리스트 용량)

lists.empty()	빈공간이면 true, 값이 있다면 false
lists.size()	원소 개수 반환
lists.max_size()	담을 수 있는 최대 크기 반환
lists.resize(숫자)	크기 변경

 

List Modifiers (리스트 조작)

clear()	모든 원소 제거
assign()	기존 원소 제거 후 n개 원소 할당
insert()	삽입
emplace()	위치에 삽입
erase()	위치에 있는 원소 삭제
push_front()	앞에 원소 삽입
emplace_front()	내부 생성 후 앞에 원소 추가
pop_front()	처음 원소 제거
push_back()	끝에 원소 추가
emplace_back()	내부 생성 후 뒤에 원소 추가
pop_back()	마지막 원소 제거
swap()	list a list b 바꿈

List operations

merge()	list a list b 병합
splice()	2개의 list에서 지정된 원소들을 이동
remove()	특정 값 제거
remove_if()	조건 만족 하는 것 제거
reverse()	역순으로 바꿈
unique()	중복된 값 제거
sort()	정렬 (greater<int>() 역순?)

 

Stack

stack<Type> name;	기본생성 stack<string> st;
stack<Type, Container Type(deque)> name	컨테이너 구조 변경 생성 stack<stack, vector<string>> st

s.push(data)	stack<int> s에 data추가
s.pop()	s의 top데이터 삭제
s.top()	s의 top데이터 반환
s.size()	stack 사이즈 반환
s.empty()	stack이 비어있는지 확인
s.swap(s1,s2)	두 s1, s2의 데이터 스왑하기

 

Queue

queue<Type> name;

q.push(data);	queue<int >q에 data를 추가
q.pop()	q의 front 데이터 삭제
q.front()	q의 최상위 데이터 반환
q.back()	q의 최하위 데이터 반환
q.size()	q의 현재 사이즈 반환
q.empty()	q가 비어있는지 확인
q.swap(q1,q2)	두 q1 q2의 데이터 스왑하기.

 

Priority_Queue

priority_queue<Type> name;

q.push(data);	priority_queue<int >q에 data를 추가
q.pop()	q의 front 데이터 삭제
q.front()	q의 최상위 데이터 반환
q.back()	q의 최하위 데이터 반환
q.size()	q의 현재 사이즈 반환
q.empty()	q가 비어있는지 확인
q.swap(q1,q2)	두 q1 q2의 데이터 스왑하기.

 

Dequeue

begin()	첫 번째 원소
end()	마지막 원소 다음
assign()	n개 원소(m으로) 초기화
front()	첫번째 원소
back()	마지막 원소
at()	i번째 원소
push_front()	앞에 삽입
push_back()	뒤에 삽입
pop_front()	첫 번째 원소 삭제
pop_back()	마지막 원소 삭제
insert()	n번째에 m추가
empty()	비어있는지 확인
size()	원소 수
resize()	크기 변경
clear()	삭제
erase(iter)	원소삭제

 

Pair

#include <utility> (algorithm, vector)

pair<Type, Type> pr;
pair<Type, Type>(value, value)

first()
second()
make_pair(value, value);

operator (==, !=, <, >, <=, >=)

 

Set, multiSet

set<Type> name;
set<Type, greater<int>> name;	내림차순
set<Type> name(s2);	s2 복사
set<Type> name(a, b);	a ~ b로 초기화된 원소
set<pair<Type, Type>> name;
multiset<Type> name;
multiset<vector<Type>> name;

begin()	첫 번째 원소
end()	마지막 원소 다음
rbegin()	역 순차열의 첫 원소
rend()	역 순차열의 끝
lower_bound(k)	k의 iter
upper_bound(k)	k의 다음 iter
find(k)	k의 iter, 없으면 end() iter리턴
equal_range(k)	k 원소의 반복자 구간인 pair 객체를 반환
assign()	n개 원소(m으로) 초기화
insert(k)	정렬된 위치에 k삽입
count(k)	k의 개수
empty()	비어있는지 확인
size()	원소 수
max_size()	최대 원소 개수
clear()	삭제
erase(iter)	원소삭제
erase(iter, iter2)	range 원소 삭제

map, multimap

begin	첫 번째 요소
end	마지막 요소 다음
rbegin	역방향 첫 번째 요소
rend	역방향 마지막 요소 다음
crbegin	역방향 첫 번째 요소 (const)
crend	역방향 마지막 요소 다음 (const)
clear	multimap의 모든 요소를 지웁니다.
contains	지정된 요소가 있는지 확인합니다.
count	키와 일치하는 요소 수를 반환합니다.
emplace	생성된 요소를 map에 삽입합니다.
emplace_hint	배치 힌트를 사용하여 생성된 요소를 삽입합니다.
empty	비어 있는지 여부
equal_range	지정된 값과 일치하는 요소 범위
erase	지정된 위치 또는 키, 범위 제거
find	지정된 키와 같은 키를 가진 요소의 첫 번째 위치
insert	multimap에 요소 또는 요소의 범위를 삽입합니다.
lower_bound	지정된 키보다 같거나 큰 키를 가진 첫 번째 요소
upper_bound	지정된 키보다 큰 키를 가진 첫 번째 요소
max_size	multimap의 최대 길이를 반환합니다.
size	multimap에 있는 요소 수를 반환합니다.
swap	두 multimap의 요소를 교환합니다.
value_comp	멤버 함수는 키 값을 비교하여 요소 순서를 결정하는 함수 개체를 반환
key_comp	키를 정렬하기 위해 사용하는 비교 개체의 복사본을 검색

Algorithm

#include<algorithm>

sort(start, end)	정렬
sort(start, end, greater<int>())	내림차순
max(a, b)	큰 값
min(a, b)	작은 값
*max_element(start, end)	최댓값
*min_element(start, end)	최솟값
unique(start, end)	중복 제거 (sort 필수)
find(start, end, value)	값 찾기
reverse(start, end)	역순

bool compare(pair<int,string> a, pair<int,string> b)// 내림차순 예시
{
	if (a.first == b.first) return (a.second > b.second);
    return (a.first > b.first);
}

sort(v.begin(), v.end());
sort(v.begin(), v.end(), compare);

v.erase(unique(v.begin(), v.end()), v.end());
unique(v1.begin(), v1.end());
unique(v2.begin(), v2.begin() + 5);

binary

#include <bitset>

bitset<2진법 자리수> name(10진수)
to_string()	bitset변수를 string으로 변환
count()	1의 개수