주로 이럴 때 사용합니다.
[map]
삽입과 동시에 정렬해야할 때
많은 데이터를 보관해야 하고, 검색이 빨라야 할 때
데이터 삽입, 삭제가 적을 때
key와 value의 쌍을 원소로 저장하며,(pair 사용) key는 중복될 수 없다. (중복 key를 저장해야 한다면 multimap)
데이터가 적다면 메모리 낭비와 검색시 오버헤드가 존재한다.
[set]
삽입과 동시에 정렬해야 할 때
많은 데이터를 보관해야 하고, 검색이 빨라야 할 때
많은 데이터가 중복 되어서는 안 되며 빠른 검색으로 key의 존재 여부를 신속하게 알고 싶을때
(중복 key를 저장해야 한다면 multiset)
예제 소스코드(1)
#include <iostream>
#include <map>
using namespace std;
int main()
{
map<int, int> room_map;
int n;
int max = 0;
int compareNum = -1;
int count = 0;
cin >> n;
for (int i = 0, s, k; i < n; i++) {
cin >> s >> k;
if (room_map.find(s) != room_map.end() &&
room_map.find(s)->first < s) {
continue;
}
room_map[k] = s;
}
for (map<int, int>::iterator i = room_map.begin(); i != room_map.end(); i++) {
if (compareNum < i->second) {
compareNum = i->first;
count++;
cout << i->first << " " << i->second << " compareNum = " << compareNum << endl;
}
}
cout << count;
return 0;
}
예제 소스코드(2)
#include <iostream>
#include <set>
using namespace std;
int main()
{
multiset<int> rope;
int max = -1;
int n;
cin >> n;
for (int i = 0, k; i < n; i++) {
cin >> k;
rope.insert(k);
}
multiset<int>::reverse_iterator ri = rope.rbegin();
int i = 1;
while (ri != rope.rend()) {
if (max < *ri * i) {
max = *ri * i;
}
ri++;
i++;
}
cout << max << endl;
return 0;
}
주로 이럴 때 사용합니다.
동적 배열처럼 사용할 때
중간에 삽입, 삭제를 거의 하지 않을 때
검색을 거의 하지 않을 때
랜덤 액세스를 자주 할 때
주요 함수
[iterators]
begin
end
rbegin : 역 순차열의 첫 번째 원소를 가리키는 반복자
rend : 역 순차열의 마지막 원소를 가리키는 반복자
[Element Access]
at : n번째 원소를 참조할 때
operator[] : n번째 원소를 참조할 때 (at보다 빠름)
front : 첫 번째 원소 리턴
back : 마지막 원소 리턴
[Capacity]
empty : 원소 존재 유무 반환
size : 원소 개수
max_size : 담을 수 있는 원소의 최대 개수 리턴
resize : 크기 변경
capacity : vector에 할당된 메모리의 크기 리턴
reserve : 지정한 크기 만큼의 메모리 미리 할당
shrink_to_fit : 사용되지 않는 capacity size 제거
[Modifiers]
clear : 모든 원소 제거
assign : 기존 원소 모두 제거 후 임의의 n개 원소 할당
insert : 삽입
erase : 삭제
push_back : 끝에 삽입
pop_back : 마지막 원소 제거
swap : v1, v2있고 두 개를 swap 할 때
예제 소스코드(1)
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> vec;
vec.push_back(10); // 맨 뒤에 10 추가
vec.push_back(20); // 맨 뒤에 20 추가
vec.push_back(30); // 맨 뒤에 30 추가
vec.push_back(40); // 맨 뒤에 40 추가
for (vector<int>::size_type i = 0; i < vec.size(); i++) {
std::cout << "vec 의 " << i + 1 << " 번째 원소 :: " << vec[i] << std::endl;
}
}
예제 소스코드(2)
vector<string> record = {
{"Enter uid1234 Muzi"},
{"Enter uid4567 Prodo"},
{"Leave uid1234"},
{"Enter uid1234 Prodo"},
{"Change uid4567 Ryan"}
};
예제 소스코드(3)
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> vec(N, 0);
for(int i=0;i<N;i++)
scanf("%d",&vec[i]);
for (vector<int>::size_type i = 0; i < vec.size(); i++)
std::cout << vec[i] << std::endl;
예제 소스코드(4)
// 2차원배열 선언방법 arr[6][5]
vector<vector<int>> arr(6, vector<int>(5, 0));
주로 이럴 때 사용합니다.
검색을 거의 하지 않을 때
중간에 삽입, 삭제를 자주할 때
랜덤 액세스를 하지 않을 때
* forward_list : list처럼 양방향이 아닌 단방향으로 충분할 때
주요 함수 (vector와 중복되는 부분은 제외 했습니다)
(List operations)
merge : list1에 list2를 정렬하면서 병합
splice : list1, list2있고 특정 원소를 특정 리스트에 이동시킬 때
remove : 인자로 받은 값과 동일한 원소 모두 제거
remove_if : 함수객체의 조건을 만족하는 원소 모두 제거
reverse : 역순으로 바꿀 때
unique : 현재 원소들 중 연속적으로 중복된 값이 배치된 원소를 제거
sort : 오름차순 정렬
예제 소스코드
``` c++
#include
using namespace std;
int main()
{
list
cin >> n;
// 리스트에 원소 삽입
for (int i = 0, k; i < n; i++) {
cin >> k;
numList.push_back(k);
}
// 리스트 오름차순 정렬
numList.sort();
// 리스트 출력
list<int>::iterator iter = numList.begin();
while (iter != numList.end()) {
cout << *iter << endl;
iter++;
}
// 리스트 반대로 출력
list<int>::reverse_iterator ri = numList.rbegin();
while (ri != numList.rend()) {
cout << *ri << endl;
ri++;
}
return 0; }
자바스크립트에서 var만 사용해야 했지만
es6부터 let과 const를 사용할 수 있게 되었습니다
각 특징을 나열하면 다음과 같습니다.
var
재선언 가능
재할당 가능
let
재선언 불가능
재할당 가능
const
재선언 불가능
재할당 불가능
var vs letexample.js
if (true) {
var str1 = '1';
let str2 = '2';
}
console.log(str1);
console.log(str2);
출력
1
error
var은 함수 단위의 유효 범위로 if문 안에서 정의해도 밖에서도 사용 가능합니다.
let은 블록 단위의 유효 범위로 밖에선 사용 불가능합니다.
따라서 1은 출력되지만 2는 오류로 인해 출력할 수 없습니다.
example.js
let str = "1";
if (true) {
let str = "2";
console.log(str);
}
console.log(str);
출력
2
1
let은 var와 다르게 전역변수와 지역변수처럼
유효범위를 구분되게 사용할 수 있습니다.
example.js
let str = "1";
if (true) {
console.log(value);
let str = "2";
}
출력
error
단, let변수를 함수 단위에서 선언해서 전역변수처럼 사용하려는 경우
블록 단위에서 같은이름으로 재선언하면 호이스팅이 일어나기 때문에
변수선언의 위치에 따라 에러가 발생할 수 있습니다.
let vs constconst도 let처럼 블록단위로 스코프를 정의할 수 있습니다.
let과의 차이점은 선언과 동시에 값을 할당해야합니다.
그 후, 재할당은 할 수 없습니다.
단, 객체를 할당한 경우 새로운 객체는 할당할 수 없지만
객체 내부의 상태는 추가 및 변경 가능합니다.
함수 호이스팅이란?
간략히 말하면 함수를 선언하기 전에 호출이 가능한 것입니다.
아래의 예제로 살펴보겠습니다.
소스코드 — example.js
test();
function test() {
console.log("hello");
}
가능
example.js
test();
var test = function () {
console.log("hello");
}
오류 (함수를 선언문이 아닌 구현식으로 사용하는 것은 불가합니다)
example.js
var test = function () {
console.log("hello");
}
test();
가능 (이처럼 구현식은 호이스팅이 안되므로 미리 선언해서 사용해야 합니다)
지난번 예제에서 function을 export로 내보내고 import로 가져와서 사용해봤습니다. 이번 예제에서는 class를 다룬 간단한 예제를 살펴보겠습니다.
index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Module Sample</title>
<script type="module" src="app.js"></script>
</head>
<body>
</body>
</html>
app.js
import Person from './person.js';
const chulsu = new Person(20);
chulsu.speedUp(5);
person.js
export default class Person {
constructor(speed) {
this.speed = speed;
}
speedUp(n=0) {
console.log(`before speed = ${this.speed}`);
this.speed += n;
console.log(`after speed = ${this.speed}`);
}
}
before speed = 20
after speed = 25