2018-02/c++

Template classes, operator overloading

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include "stdafx.h"
#include <cstdio>
#define FUNC(X) X*X*X
 
using namespace std;
 
class cl1 {
public:
    int a;
    int b;
    cl1() {
        a = 0;
        b = 0;
    }
    cl1(int aa, int bb) {
        a = aa;
        b = bb;
    }
    cl1 operator+(cl1 &ref) {
        return cl1(a + ref.a, b + ref.b);
    }
    cl1 operator+(int sam) {
        return cl1(a + sam, b + sam);
    }
};
 
// 전역 선언은 양쪽 연산 가능하게 한다
cl1 operator+(int num, cl1 sam) {
    return cl1(sam.a + num, sam.b + num);
}

template<class T>
class queue {
private:
    T data1;
public:
    T adddata(T da);
    queue(T da);
    T getdata();
};
 
template<class T>
T queue<T>::getdata() {
    return data1;
}
 
template<class T>
T queue<T>::adddata(T da) {
    return da + data1;
}
 
template<class T>
queue<T>::queue(T da) {
    data1 = da;
}
 
int main() {
    queue<double> q1(3.14);
    cl1 sam2(23,24);
// 생성자에 넣으려면 미리 선언한 후에 그 변수를 삽입
    queue<cl1> q2(sam2);
    cl1 sam = q2.getdata();
    printf("%i %i\n", q2.getdata().a, q2.getdata().b);
    sam = sam2;
    printf("%d %d\n", sam.a, sam.b);
    printf("%f\n", q1.adddata(1.0));
    sam = q2.adddata(sam2);
    // 10+nb1 은 10.operator+(nb1)과 동치
    printf("%d %d\n", sam.a, sam.b);
    printf("%d\n", FUNC(3));
    sam = sam.operator+(32);
// 클래스 대입 가능하다. 서로 독립적
    sam = sam + 32;
    sam = 32 + sam;
    printf("%d %d\n", sam.a, sam.b);
    while (1) {}
    return 0;
}
cs


저작자표시

'2018-02 > c++' 카테고리의 다른 글

relational data structures & strings (C++ STL)  (0) 2018.03.21
dynamic allocation of 2-dimension array  (0) 2018.03.20
c++ reference variables  (0) 2018.03.18
Template classes, operator overloading  (0) 2018.03.18
time&chronos  (0) 2018.03.17
basic data structures  (0) 2018.03.17
2018-02/c++

time&chronos

chrono library


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include "stdafx.h"
#include <iostream>
#include <chrono>
#include <ctime>
 
using namespace std;
 
long fibonacci(int n) {
    if (n < 3) return 1;
    return fibonacci(n - 1) + fibonacci(n - 2);
}
 
int main() {
    for (int i = 0; i < 30; i++) {
        chrono::time_point<chrono::high_resolution_clock> start, end;
        start = chrono::high_resolution_clock::now();
        fibonacci(i);
        end = chrono::high_resolution_clock::now();
        chrono::duration<double> elapsed_seconds = end - start;
        cout << elapsed_seconds.count() << "s" << endl;
    }
    while (1) {}
    return 0;
}
cs



저작자표시

'2018-02 > c++' 카테고리의 다른 글

relational data structures & strings (C++ STL)  (0) 2018.03.21
dynamic allocation of 2-dimension array  (0) 2018.03.20
c++ reference variables  (0) 2018.03.18
Template classes, operator overloading  (0) 2018.03.18
time&chronos  (0) 2018.03.17
basic data structures  (0) 2018.03.17
2018-02/c++

basic data structures

arrays


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
void func3(int arr[]);
void func4(int * arr);
 
int main() {
    int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
    // arr = { 3,3,3,3,3,3,3,3,3,3 }; 재정의 불가
    int * arr2 = new int[10];
    scanf("%d", &arr[1]);
    scanf("%d", &arr2[1]); // 네 동적 할당도 무조건 & 붙여서 주소로 가야됨
    // 아마 포인터긴 한데 arr2[3] 꼴이면 그 자체가 값이어서 그런듯
    func3(arr); // 이거 바뀜.. 정적어레이 함수인자 직접제어 하면 안된다
    //정적배열은 참조(&)가 기본. 참조 넣으면 에러뜸
    func4(arr2); // 이것도 바뀜
    // ** 배열은 함수인자로 보내면 기본으로 바뀜. 안바뀌게 하고싶으면 복사본 써서 작업해야할듯
    for (int i = 0; i < 11; i++) { // 인덱스 초과하면 이상한값읽음
        printf("%d ", arr[i]);
    }
    printf("\n");
    arr2 = new int[10]; // 네 그냥 초기화 됩니다
    for (int i = 0; i < 11; i++) { // 동적할당 초과하면 이상한값읽음
        printf("%d ", arr2[i]); // 초기화안한 부분은 이상한값나옴
    }
    while (1) {}
    return 0;
}
 
void func3(int arr[]) {
    arr[0] = -99;
}
 
void func4(int * arr) {
    arr[0] = -99;
}
cs


1
2
3
4
5
6
7
8
9
10
11
    int ** arr = new int*[10];
    for (int i = 0; i < 10; i++) {
        arr[i] = new int[10];
    }
    // 이차원 배열 정의
    int arr3[5][5];
    int brr[5][5];
    //int brr[5][5]; brr = arr3; 이거 안됨
    int arr4[3] = { 1,2,3 };
    int brr4[3] = { 4,5,6 };
    //arr4 = brr4; 이거도 안됨!!
cs


vectors

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
void func(vector<int> arr);
void func2(vector<int> & arr);
struct sam {
    int a;
    int b;
} hello;
class sam2 {
public:
    int a;
    int b;
    sam2(int aa, int bb);
};
sam2::sam2(int aa, int bb) {
    a = aa;
    b = bb;
}
int main() {
    vector<int> arr1;
    vector<int> arr2(32, 100); // 32개를 100으로 채운다
    vector<int> arr3[10];
    vector<int> * arr4 = new vector<int>[10];
    // arr4[i].push_back(13);
    // arr4[i].at(j)
    vector<sam> arr5;
    sam se = { 1,2 };
    arr5.push_back(se);
    // se와 arr5.at(0)은 완전히 별개가 된다
    vector<sam2> arr6;
    sam2 test(1, 2);
    arr6.push_back(test); // test와 arr6.at(0)은 완전히 별개이다
    
    arr1.push_back(13); // 맨 뒤에 추가
    arr1.insert(arr1.begin() + 1,200); // 1번째 앞에다 200 삽입
    // 즉 얘가 새로운 index 1이 된다
    
    func(arr1); // 참조가 아니라서 효과 X
    func2(arr1); // 참조라서 효과 o
    
    //arr1.erase(arr1.begin() + 1); // index 1번째 원소를 삭제
    // 즉 앞에서 두번째 원소를 삭제함
    //arr1.erase(arr1.end()-1); // 맨뒤원소 삭제
    // arr1.end()는 맨뒤 원소보다 한개 더 뒤
    //arr1.erase(arr1.begin() + 3, arr1.begin() + 5);
    // index 3에서부터 4까지 삭제 5는 삭제안함
    //arr1.erase(arr1.begin(), arr1.end()); // 전체 삭제
    arr1.clear(); // 전체 삭제
    
    arr1.size(); // 벡터 크기
    //arr1.at(0); // index 0번째 접근
    //arr1.front(); // 맨앞 원소 값
    //arr1.back(); // 맨뒤 원소 값
    for (int i : arr1) { // vector for문
        printf("%d ", i);
    }
    printf("done\n");
    while (1) {}
    return 0;
}
void func(vector<int> arr) {
    arr.push_back(11);
}
void func2(vector<int> & arr) {
    arr.push_back(11);
}
 
cs


vector 대입 ( 함수에도 값으로 보내는걸로 봐서 클래스는 스트럭트랑 같은 개념으로 주소 말고 통째로 복사해서 넘긴다. 그니까 그게 부담스러우면 포인터를 써야 될듯 )


1
2
3
4
5
6
7
8
9
    vector<int> test;
    vector<int> test2;
    test.push_back(32);
    test.push_back(30);
    test2 = test;
    test.push_back(29);
    for (int i = 0; i < test2.size(); i++) {
        cout << test2.at(i) << endl;
    }
cs

list

doubly linked list
erase O(1), insert O(1), access O(N), space complexity O(N)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include "stdafx.h"
#include <iostream>
#include <list>
#include <vector>
#include <unordered_map>
#include <map>
#include <set>
#include <unordered_set>
 
using namespace std;
 
int main() {
    list<int> sam;
    
    for (int i = 0; i < 10; i++) {
        sam.push_back(i);
    }
    
    list<int>::iterator it = sam.begin();
    
    advance(it, 3);
    
    advance(it, -1);
    
    sam.insert(it, 4444); // "it" 앞에다가 삽입해라.
    
    sam.erase(it); // "it"을 지워라!!
    
    for (it = sam.begin(); it != sam.end(); it++) {
        cout << *it << endl;
    }
 
 
    unordered_map<int, int> test;
    for (int i = 0; i < 10; i++) {
        test.insert(unordered_map<int, int>::value_type(i*2, i*3));
    }
    unordered_map<int, int>::iterator it2 = test.begin();
    advance(it2, 3);
    unordered_set<int>::iterator z;
    advance(z, 3);
    while(1){}
    return 0;
}
cs


저작자표시

'2018-02 > c++' 카테고리의 다른 글

relational data structures & strings (C++ STL)  (0) 2018.03.21
dynamic allocation of 2-dimension array  (0) 2018.03.20
c++ reference variables  (0) 2018.03.18
Template classes, operator overloading  (0) 2018.03.18
time&chronos  (0) 2018.03.17
basic data structures  (0) 2018.03.17