dev80

//

//  main.cpp

//  ExampleCpp

//

//  Created by 김일호 on 2015. 7. 10..

//  Copyright (c) 2015년 김일호. All rights reserved.

//

#include <iostream>

#include <string>

using namespace std;

void selection(int *arr);

void swap(int *num1, int *num2);

int main()

{

    int arr[5] = {4,3,9,1,2};

    selection(arr);

}

void selection(int arr[])

{

    int i, j;

    int min;

    for(i = 0; i<5-1; i++)

    {

        min = i;

        for(j = i+1; j < 5; j++)

        {

            if(arr[j] < arr[min])

                min = j;

        }

        swap(&arr[i], &arr[min]);

        cout <<i+1 <<"회전: ";

        for(int k = 0; k< 5; k++)

            cout << arr[k] << " " ;

        cout << endl;

    }

}

void swap(int *num1, int *num2)

{

    int temp;

    temp = *num1;

    *num1 = *num2;

    *num2 = temp;

}

int *Stack;

int Size;

int top=0;

void initStack(int aSize)

{

Size = aSize;

Stack = (int *)malloc(Size*sizeof(int));

}

void push(int item)

{

if (Size == top)

{

printf("Stack is Full!\n");

}

else

{

Stack[top++] = item;

printf("top is %d!\n", top);

}

}

void pop()

{

Stack[top] = 0;

}

int main()

{

initStack(10);

push(1);

push(2);

push(3);

push(4);

push(5);

push(6);

push(7);

push(8);

pop();

pop();

for (int i = 0; i < 10; i++)

{

printf("%d\n", Stack[i]);

}

}

//

//  main.cpp

//  ExampleCpp

//

//  Created by 김일호 on 2015. 7. 10..

//  Copyright (c) 2015년 김일호. All rights reserved.

//  클래스 템플릿 사용 전 각 자료형에 맞는 클래스를 생성

#include <iostream>

#include <string>

using namespace std;

class IntArray

{

    int *buf;

    int size;

    int capacity;

public:

    explicit IntArray(int cap = 100):buf(0), size(0), capacity(cap)

    {

        buf = new int[capacity];

    }

    ~IntArray() { delete[] buf;}

    void Add(int data)

    {

        buf[size++] = data;

    }

    int operator[](int idx) const

    {

        return buf[idx];

    }

    int GetSize() const

    {

        return size;

    }

};

class DoubleArray

{

    double *buf;

    int size;

    int capacity;

public:

    explicit DoubleArray(int cap=100):buf(0), size(0), capacity(cap)

    {

        buf = new double[capacity];

    }

    ~DoubleArray() {delete[] buf;}

    void Add(double data)

    {

        buf[size++] = data;

    }

    double operator[] (int idx) const

    {

        return buf[idx];

    }

    int GetSize() const {return size;}

};

class StringArray

{

    string *buf;

    int size;

    int capacity;

public:

    explicit StringArray(int cap = 100):buf(0), size(0), capacity(cap)

    {

        buf = new string[capacity];

    }

    void Add(string data)

    {

        buf[size++] = data;

    }

    string operator[] (int idx) const

    {

        return buf[idx];

    }

    int GetSize() const {return size;}

};

int main()

{

    IntArray iarr;

    iarr.Add(10);

    iarr.Add(20);

    iarr.Add(30);

    for (int i = 0; i<iarr.GetSize(); ++i)

    {

        cout << iarr[i] << endl;

    }

    DoubleArray darr;

    darr.Add(10.12);

    darr.Add(20.12);

    darr.Add(30.12);

    for (int i = 0; i<darr.GetSize(); ++i)

    {

        cout << darr[i] << endl;

    }

    StringArray sarr;

    sarr.Add("abc");

    sarr.Add("ABC");

    sarr.Add("sdfads");

    for (int i = 0; i<sarr.GetSize(); ++i)

    {

        cout << sarr[i] << endl;

    }

    return 0;

}

//클래스 템플릿 버전

//

//  main.cpp

//  ExampleCpp

//

//  Created by 김일호 on 2015. 7. 10..

//  Copyright (c) 2015년 김일호. All rights reserved.

//

#include <iostream>

#include <string>

using namespace std;

template<typename T>

class Array

{

    T *buf;

    int size;

    int capacity;

public:

    explicit Array(int cap = 100):buf(0), size(0), capacity(cap)

    {

        buf = new T[capacity];

    }

    ~Array() { delete[] buf;}

    void Add(T data)

    {

        buf[size++] = data;

    }

    T operator[](int idx) const

    {

        return buf[idx];

    }

    int GetSize() const

    {

        return size;

    }

};

int main()

{

    Array<int> iarr;

    iarr.Add(10);

    iarr.Add(20);

    iarr.Add(30);

    for (int i = 0; i<iarr.GetSize(); ++i)

    {

        cout << iarr[i] << endl;

    }

    Array<double> darr;

    darr.Add(10.12);

    darr.Add(20.12);

    darr.Add(30.12);

    for (int i = 0; i<darr.GetSize(); ++i)

    {

        cout << darr[i] << endl;

    }

    Array<string> sarr;

    sarr.Add("abc");

    sarr.Add("ABC");

    sarr.Add("sdfads");

    for (int i = 0; i<sarr.GetSize(); ++i)

    {

        cout << sarr[i] << endl;

    }

    return 0;

}

클래스를 템플릿화 시키면서 클라이언트에서는 자료형에 상관없이 클래스에 사용될 타입을 정의할 수 있다.

#include <iostream>

#include <algorithm>

using namespace std;

/**********************/

/*

class Equal {

int x, y;

public :

Equal() {}

Equal(int x, int y) { x = this->x; y = this->y; }

~Equal() {}

bool cmp_func()

{

return x == y  ? true : false;

}

};

int main()

{

Equal cmp(2, 2);

cout << cmp.cmp_func() << endl;

return 0;

}

*/ 

/******* 함수 객체 사용 ***************/ 

class Equal {

int x, y;

public:

Equal() {}

~Equal() {}

bool operator() (int x, int y)

{

return x == y ? true : false;

}

};

int main()

{

Equal cmp;

if (cmp(2, 2))

{

cout << "같다" << endl;

}

else

{

cout << "다르다" << endl;

}

return 0;

}

함수 객체는 함수처럼 동작하는 객체, 함수처럼 동작하려면 객체가 '()' 연산자를 정의해야 한다.

즉 () 연산자를 오버로딩한 객체가 함수 객체

#include <iostream>

#include <algorithm>

using namespace std;

struct Functor1 {

void operator() (int n)

{

cout << n << " ";

}

};

struct Functor2 {

void operator() (int n)

{

cout << n*n << " ";

}

};

struct Functor3 {

void operator() (int n)

{

cout << "정수 : " << n << endl;

}

};

int main()

{

int arr[5] = { 10,20,30,40,50 };

for_each(arr, arr + 5, Functor1());

cout << endl << endl;

for_each(arr, arr + 5, Functor2());

cout << endl << endl;

for_each(arr, arr + 5, Functor3());

return 0;

}

함수 포인터는 함수의 시작 주소를 저장하는 포인터

함수의 이름은 함수가 시작하는 시작 주소를 나타내며 함수 포인터는 이 함수의 주소를 저장하는 포인터!

#include <iostream>

#include <cstring>

using namespace std;

class Point

{

int x;

int y;

public:

explicit Point(int _x = 0, int _y = 0) :x(_x), y(_y) {}

void Print() const { cout << x << ", " << y << endl; }

void PrintInt(int n) { cout << "테스트정수: "<< n << endl; }

};

int main()

{

Point pt(2, 3);

Point *p = &pt;

void (Point::*pf1)() const; //멤버 함수 포인터 선언

pf1 = &Point::Print;

void(Point::*pf2)(int); //멤버 함수 포인터 선언

pf2 = &Point::PrintInt;

pt.Print();

pt.PrintInt(10);

cout << endl;

(pt.*pf1)();

(pt.*pf2)(10);

cout << endl;

(p->*pf1)();

(p->*pf2)(10);

return 0;

}

#include <iostream>

#include <cstring>

using namespace std;

class String {

char buf[1000];

public:

String(const char* sz) 

{

strcpy(buf, sz);

}

~String() {}

operator const char* () const 

{

return buf;

}

};

int main()

{

String s("Hello");

const char* sz = s;

cout << sz << endl;

}

operator const char* () const
{
 return buf;
}

형변환 연산자 오버로딩

return buf; 이므로 String 클래스 안에 있는 맴버 buf를 return

형변환 연산자 오버로딩은 

operator 타입명 () const

으로 원형을 정의한다.

#include <iostream>

using namespace std;

class Point {

int x;

int y;

public:

Point(int _x = 0, int _y = 0) :x(_x), y(_y) {}

void Print() const { cout << x << ", " << endl; }

};

class PointPtr

{

Point *ptr;

public:

PointPtr(Point *p) :ptr(p) {}

~PointPtr() { delete ptr; }

Point* operator->() const

{

return ptr;

}

Point& operator*() const

{

return *ptr;

}

};

int main()

{

Point* p1 = new Point(2, 3);

PointPtr p2 = new Point(5, 5);

p1->Print();

p2->Print();

return 0;

}

p1은 일반 포인터, p2가 스마트 포인터

#include <iostream>

using namespace std;

class Point {

int x, y;

public:

Point(int _x = 0, int _y = 0) :x(_x), y(_y) {}

void Print() const {

cout << x << ", " << y << endl;

}

const Point operator+(const Point &arg) const

{

Point pt;

pt.x = this->x + arg.x;

pt.y = this->y + arg.y;

return pt;

}

const Point& operator++()

{

++x;

++y;

return *this;

}

const Point operator++(int)

{

Point pt(x, y);

++x;

++y;

return pt;

}

};

int main()

{

Point pt1(2, 3);

Point pt2(3, 5);

++pt2;

Point pt3;

pt3 = pt1 + pt2;

pt3.Print();

pt2.Print();

return 0;

}