/*****************************************************************************
*  -------------------------------- list.h --------------------------------  *
*****************************************************************************/
#ifndef LIST_H
#define LIST_H
#include <stdlib.h>
/*****************************************************************************
*  Define a structure for linked list elements.                              *
*****************************************************************************/
typedef struct ListElmt_ {
 void               *data;
 struct ListElmt_   *next;
} ListElmt;
/*****************************************************************************
*  Define a structure for linked lists.                                      *
*****************************************************************************/
typedef struct List_ {
 int                size;
 int                (*match)(const void *key1, const void *key2);
 void               (*destroy)(void *data);
 ListElmt           *head;
 ListElmt           *tail;
} List;
/*****************************************************************************
*  --------------------------- Public Interface ---------------------------  *
*****************************************************************************/
void list_init(List *list, void (*destroy)(void *data));
void list_destroy(List *list);
int list_ins_next(List *list, ListElmt *element, const void *data);
int list_rem_next(List *list, ListElmt *element, void **data);
#define list_size(list) ((list)->size)
#define list_head(list) ((list)->head)
#define list_tail(list) ((list)->tail)
#define list_is_head(list, element) ((element) == (list)->head ? 1 : 0)
#define list_is_tail(element) ((element)->next == NULL ? 1 : 0)
#define list_data(element) ((element)->data)
#define list_next(element) ((element)->next)
#endif



'Programing > 자료구조' 카테고리의 다른 글

이중연결리스트.cpp  (0) 2016.12.01
단일연결리스트.cpp  (0) 2016.11.30
이중연결리스트  (0) 2016.11.30
단일연결리스트 head만 사용  (0) 2016.11.30
단일 연결리스트 더미노드  (0) 2016.11.30
//******************************************************************************
// 이중연결리스트 !!
//******************************************************************************
// 단일연결리스트 -> 단방향성
//*****************************5*************************************************
#include <stdio.h>
#include <malloc.h>
//******************************************************************************
// 구조체 선언
//******************************************************************************
typedef struct _Node
{
int data; // data
struct _Node * next; //다음 링크
struct _Node * prev; //이전 링크
}Node;
//******************************************************************************
//head , tail 더미 노드 활용 !!
//******************************************************************************
Node *head;
//******************************************************************************
// Utill
//******************************************************************************
Node *CreateNode(int data) //노드 생성
{
Node *Newnode = (Node *)malloc(sizeof(Node));
Newnode->data = data;
Newnode->next = NULL;
Newnode->prev = NULL;
return Newnode;
}
//******************************************************************************
void init()
{
head = CreateNode(0);
head->next = NULL;
head->prev = head;
}
//******************************************************************************
// 삽입연산 함수들
//******************************************************************************
void push_back(int data)
{
Node *Newnode = CreateNode(data);
Newnode->next = NULL;
tail->prev->next = Newnode;
Newnode->prev = tail->prev;
tail->prev = Newnode;
}
void push_front(int data)
{
Node * Newnode = CreateNode(data);
Newnode->prev = head;
head->next->prev = Newnode;
Newnode->next = head->next;
head->next = Newnode;
}
void insert(int key, int data)
{
Node *p = head->next;
Node *Newnode = CreateNode(data);
while(p != tail){
if(p->data == key){
Newnode->next = p->next;
Newnode->prev = p;
p->next->prev = Newnode;
p->next = Newnode;
return;
}
else{
p = p-> next;
}
}
Newnode->next = tail;
tail->prev->next = Newnode;
Newnode->prev = tail->prev;
tail->prev = Newnode;
}
//******************************************************************************
//삭제연산 함수들
//******************************************************************************
void pop_back()
{
Node *p = tail->prev;
if(tail->prev == head){
printf("list empty !!!");
}
else{
p->prev->next = tail;
tail->prev = p->prev;
free(p);
}
}
void pop_front()
{
Node *p = head->next;
if(head->next == tail){
printf("list empty");
}
else{
head->next = p->next;
free(p);
}
}
void erase(int key)
{
Node *p = head->next;
Node *s;
while(p != tail){
if(p->data == key){
p->prev->next = p->next;
p->next->prev = p->prev;
s = p->next;
free(p);
p = s;
//return;
}
else{
p = p-> next;
}
}
}
//******************************************************************************
void show()
{
Node *p = head->next;
while(p != tail)
{
printf("%d-->", p->data); 
p = p->next;
}
puts("");
}


void main()
{
init();
push_back(30);
show();
push_back(50);
show();
push_front(30);
show();
push_front(30);
show();
push_front(50);
show();
push_front(30);
show();
erase(30);
show();
}


'Programing > 자료구조' 카테고리의 다른 글

단일연결리스트.cpp  (0) 2016.11.30
단일연결리스트.h  (0) 2016.11.30
단일연결리스트 head만 사용  (0) 2016.11.30
단일 연결리스트 더미노드  (0) 2016.11.30
자료구조  (0) 2016.11.30
//****************************************************************************
//단일 연결리스트 head노드만을 이용 !!
//****************************************************************************

#include <stdio.h>
#include <stdlib.h>

typedef struct _Node
{
int data;
struct _Node *next;
}Node;
//****************************************************************************
Node * head;
//****************************************************************************
Node *CreateNode(int data)
{
Node * newnode = (Node *)malloc(sizeof(Node));
newnode->data = data;
newnode->next = NULL;
return newnode;
}//노드 생성 함수 !!
//****************************************************************************
void init()
{
head = CreateNode(0);
}
//****************************************************************************
// 삭제 함수
//****************************************************************************
//맨 뒤의 노드를 삭제 !!
//****************************************************************************
void pop_back()
{
Node *p, *s;
if(head->next == NULL){
puts("list empty !!");
}
else{
s= head;
p = head->next;
while(p->next != NULL){
s = p;
p = p->next;
}
}
s ->next = NULL;
free(p);
}
//****************************************************************************
//맨 앞의 노드를 삭제 !!
//****************************************************************************
void pop_front()
{
Node *p;
if(head->next == NULL){
printf("list empty !! \n");
}
else{
p = head->next;
head->next = p->next;
free(p);
}
}
//****************************************************************************
// data에 해당하는 노드 삭제!!
//****************************************************************************
void erase_value(int data)
{
Node *p,*s;
p = head->next;
s = head;
while(p->next != NULL){
if(p->data == data){
s->next = p->next;
free(p);
return;
}
else{
s=p;
p = p->next;
}
}
printf("No date");
puts("");
}
//****************************************************************************
// 1번째 3번째
//****************************************************************************
void erase_idx(int idx)
{
Node *p,*s;
p = head->next;
s = head;
int i=0;
while(p->next != NULL){
if(i == idx-1){
s->next = p->next;
free(p);
return;
}
else{
s = p;
p = p->next;
}
i++;
}
printf("No date");
puts("");

}
//****************************************************************************
//****************************************************************************
//입력 함수들
//****************************************************************************
void push_back(int data)
{
Node * p = head;
Node * newnode = CreateNode(data);
while(p->next != NULL)
{
p = p->next;
}
p ->next = newnode;
}
void push_front(int data)
{
Node *newnode = CreateNode(data);
newnode->next = head->next;
head->next = newnode;
}
void insert(int key, int data)
{
Node * p = head->next;
while(p->next != NULL){
if(p->next->data == key) {
Node * newnode =CreateNode(data);
newnode->data = data;
newnode->next = p->next;
p->next = newnode;
return;
}
else{
p = p->next;
}
}
push_back(data);
}
void insert_back(int key, int data)
{
Node *p = head->next;
while(p->next !=NULL){
if(p->data == key){
Node *newnode = CreateNode(data);
p->next->data = data;
newnode->next = p->next;
p->next = newnode;
return;
}
else{
p = p->next;
}
}
push_back(data);
}
void show()
{
Node * p = head->next;
while(p != NULL){
printf("%d --> ",p->data);
p = p->next;
}
puts("");
}
int Find_Number(int num)
{
Node *p=head;
while(p->next != NULL)
{
if(p->data == num)
{
printf("%d\n",p->data);
return p->data;
}
else
{
p = p->next;
}
}
puts("nonono");
return 0;
}
int Fine_idx(int data)
{
int i=0;
Node *p=head;
while(p->next != NULL){
if(i == data){
printf("%d\n",p->data);
return p->data;
}
else{
p = p->next;
}
i++;
}
puts("nonono");
return NULL;
}
int Fine_Back()
{
Node *p = head;
while(p->next != NULL){
p = p->next;
}
printf("%d\n",p->data);
return p->data;
}
int Fine_Start()
{
Node *p = head->next;
if(p){
printf("%d\n",p->data);
return p->data;
}
else{
puts("empty data");
}
return 0;
}

void main()
{
init();
push_back(5);
show();
push_back(4);
show();
push_front(2);
show();
push_front(15);
show();
push_front(17);
show();
insert(2,40);
show();
insert_back(15,33);
show();
Find_Number(2);
Fine_idx(1);

}


'Programing > 자료구조' 카테고리의 다른 글

단일연결리스트.cpp  (0) 2016.11.30
단일연결리스트.h  (0) 2016.11.30
이중연결리스트  (0) 2016.11.30
단일 연결리스트 더미노드  (0) 2016.11.30
자료구조  (0) 2016.11.30
/****************************************************************************
// 연결리스트 !!
// -> 배열의 단점을 극복하기 위한 동적 자료구조 !
// -> 정적 --> 동적배열 -> 연결리스트 !!
// -> 중간에서 삽입 삭제 문제 !!
//****************************************************************************
// 1) 필요할때만 동적으로 생성하여 사용한다 !!
// 2) 링크에 변경을 통해서 삽입 삭제가 빠르다 !!
//****************************************************************************
//****************************************************************************
// 단일연결리스트 ( head, tail ) 더미 노드활용 !!
//****************************************************************************
#include <stdio.h>
#include <stdlib.h>
//****************************************************************************
// 구조체 선언
//****************************************************************************
typedef struct _Node
{
int date; // 데이타 저장 변수
struct _Node * next; // 링크!!
}Node;
//****************************************************************************
//더미 포인터 선언
//****************************************************************************
Node *head, *tail;
//****************************************************************************
// 초기화 !!
// 기능 : head , tail 생성 및 링크 연결 !!
//****************************************************************************
void init()
{
head = (Node *)malloc(sizeof(Node));
tail = (Node *)malloc(sizeof(Node));

head->next = tail;
tail->next = tail;
head->date = 0;
tail->date = 0;
}
//****************************************************************************
void push_back(int date) // 리스트의 맨 뒤에 삽입
{
// 1) 노드 생성 초기화 !!
Node *newnode = (Node *)malloc(sizeof(Node));
newnode->date = date;
newnode->next = NULL;
// 2) tail 앞에 노드 !!
Node *p = head;
while(p->next != tail){
p = p->next;
}
newnode->next = p->next;
p->next = newnode;
}
//****************************************************************************
void push_front(int date) // 리스트의 맨 앞에 삽입
{
Node *newnode = (Node *)malloc(sizeof(Node));
newnode->date = date;
newnode->next = NULL;
newnode->next = head->next;
head->next = newnode;
}
//****************************************************************************
void insert(int key, int date) //key값 뒤에 삽입
{
Node * p = head->next;
while(p->next != tail){
if(p->date == key){
Node * newnode = (Node *)malloc(sizeof(Node));
newnode->date = date;
newnode->next = p->next;
p->next = newnode;
return;
}
else{
p = p->next;
}
}
push_back(date);

}
//****************************************************************************
void front_insert(int key, int date)  //key값 앞에 삽입
{
Node * p = head->next;
while(p->next != tail){
if(p->next->date == key) {
Node * newnode = (Node *)malloc(sizeof(Node));
newnode->date = date;
newnode->next = p->next;
p->next = newnode;
return;
}
else{
p = p->next;
}
}
push_back(date);
}
//****************************************************************************
// 삭제 함수
//****************************************************************************
//맨 뒤의 노드를 삭제 !!
//****************************************************************************
void pop_back()
{
Node *p, *s;
p = head->next;
s = head;
while(p->next != tail){
s = p;
p = p->next;
}
s->next = p->next;
free(p);
}
//****************************************************************************
//맨 앞의 노드를 삭제 !!
//****************************************************************************
void pop_front()
{
if(head->next == tail){
printf("list empty !! \n");
}
else{
Node *p;
p = head->next;
head->next = p->next;
free(p);
}
}
//****************************************************************************
// date에 해당하는 노드 삭제!!
//****************************************************************************
void erase_value(int date)
{
Node *p,*s;
p = head->next;
s = head;
while(p->next != tail){
if(p->date == date){
s->next = p->next;
free(p);
return;
}
else{
s=p;
p = p->next;
}
}
printf("No date");
puts("");
}
//****************************************************************************
// 1번째 3번째
//****************************************************************************
void erase_idx(int idx)
{
Node *p,*s;
p = head->next;
s = head;
int i=0;
while(p->next != tail){
if(i == idx-1){
s->next = p->next;
free(p);
return;
}
else{
s = p;
p = p->next;
}
i++;
}
printf("No date");
puts("");

}
//****************************************************************************

// 출렵 함수( 리트스의 모든 원소를 출력)
//****************************************************************************
void show()
{
Node * p = head->next;
while(p != tail){
printf("%d --> ",p->date);
p = p->next;
}
puts("");
}
//****************************************************************************
void main()
{
init();
push_back(10);
push_back(20);
push_back(30);
push_front(100);
push_back(200);
erase_idx(1);
show();
}



'Programing > 자료구조' 카테고리의 다른 글

단일연결리스트.cpp  (0) 2016.11.30
단일연결리스트.h  (0) 2016.11.30
이중연결리스트  (0) 2016.11.30
단일연결리스트 head만 사용  (0) 2016.11.30
자료구조  (0) 2016.11.30
//**자료구조**
// 선형 자료구조-[][][][][][][][][][][] 일렬로 늘어놓은 것
// 리스트(목록)
// - 배열(연접리스트 -연속된공간에 접해있다)
// (정적 배열(컴파일시 생성), 동적 배열(실행중 생성), 포인터 배열 , 동적포인터배열)
//
// - 링크드 리스트(연결 리스트)
// (단일연결 리스트, 이중연결 리스트, 환형 연결리스트)
// - 제한된 선형 자료구조
//  제한? 삽입과 삭제에 대한 제한!
//  Queue(대기열(줄서기) ->후입선출)
//  Stack(선입선출)
// 비선형 자료구조
// -나무(tree) 계층적 구조나 조직을 나타냄 - 조직도 ceo밑에 관리부서- 관리직원
// -그라프
//
//**자료구조**
// 영어공부-> 대화, 신문, 소설, 영화
// C,C++ ->  자료구조(게임, OS, Application, ...)
// C,C++를 응용해서 만드는 것...(영어를 공부해서 외국인을 만난거랑 같음..) -> 자료구조
// 자료구조는 외울 수 없다...(응용하는 것이기 때문에)
//데이터 -> 메모리 -> 메모리안의 데이터들을 논리적으로 어떻게 도식화 시킬것인가?? -> 자료구조
//FC BIT
//선수, 임원 , 코치
//선수목록 [][][][][][][][]...
//임직원 [][][][][][][][]...

//자료구조에는 위의 배열의 나열이 아닌 아래구조처럼 데이터를 관리하는 것을 배운다.
// 조직도 [단장]
//   │
// [감독]
//   │
//   ┌───┴───┐
// [수비] [공격코치]


'Programing > 자료구조' 카테고리의 다른 글

단일연결리스트.cpp  (0) 2016.11.30
단일연결리스트.h  (0) 2016.11.30
이중연결리스트  (0) 2016.11.30
단일연결리스트 head만 사용  (0) 2016.11.30
단일 연결리스트 더미노드  (0) 2016.11.30

스마트 포인터


스마트 포인터는 동적으로 할당 (힙) 개체에 포인터를 저장하는 개체입니다. 그들은 많은과 같은 내장 C + + 포인터들이 자동으로 객체가 적절한 시간에 지적 삭제할 것을 제외하면 동작합니다. 그들은 동적으로 할당된 객체의 적절한 파괴를 위해 같은 스마트 포인터는 예외의 얼굴에 특히 유용합니다. 그들은 또한 여러 소유자가 공유 동적으로 할당된 객체를 추적하는 데 사용할 수 있습니다.

개념 스마트 포인터는 객체가 지적 소유로 볼 수 있으며, 그것이 더 이상 필요하지 않은 개체의 삭제에 대한 책임을 따라서.

스마트 포인터 라이브러리 여섯 스마트 포인터 클래스 템플릿을 제공합니다 :


scoped_ptr<boost/scoped_ptr.hpp>단일 개체의 단순 단독 소유. Noncopyable.
scoped_array<boost/scoped_array.hpp>배열의 간단한 단독 소유. Noncopyable.
shared_ptr<boost/shared_ptr.hpp>개체 소유권은 여러 포인터 사이에 공유.
shared_array<boost/shared_array.hpp>배열 소유권은 여러 포인터 사이에 공유.
weak_ptr<boost/weak_ptr.hpp>비 소유 shared_ptr가 소유한 개체의 관측합니다.
intrusive_ptr<boost/intrusive_ptr.hpp>임베디드 참조 카운트와 개체의 소유권을 공유.


 auto_ptr 템플릿 :이 템플릿은 표준을 보완하기 위해 고안되었습니다.

using namespace std;
class Stu
{
//*******************************************************originStu*************************************
class OriginStu
{
int num;
string name;
int rcnt;
public :
OriginStu(int _num,string _name)
{
num = _num;
name = _name;
rcnt = 1;
}
void AddRef()
{
rcnt++;
}
int Release()
{
rcnt--;
return rcnt;
}
};
//*******************************************************originStu*************************************
OriginStu *ostu;
public :
Stu(int _num,string _name)
{
ostu = new OriginStu(_num,_name);
}
Stu(const Stu &stu)
{
*this = stu;
ostu->AddRef();
}
~Stu()
{
if(ostu->Release()){
return;
}
delete ostu;
}
};


void main()
{
Stu s(2,"홍길동");
Stu s2(s);
}





///////////////////////////////////////////////////////


#include "stdafx.h"
using namespace std;

template<typename T>
class CountedPtr
{
private:
  
  struct Impl
  {
    T* p;
    size_t refs;

    Impl(T* pp) : p(pp), refs(1)  {}
    ~Impl()              { delete p; }
  };

  Impl* impl_;

public:
  explicit CountedPtr(T* p) : impl_( new Impl(p))    {}
  ~CountedPtr()                    { Decrement(); }
  CountedPtr(const CountedPtr& other) : impl_(other.impl_)    { Increment(); }
  CountedPtr& operator=(const CountedPtr& other)
  {
    if(impl_ != other.impl_)
    {
      Decrement();
      impl_ = oter.impl_;
      Increment();
    }
    return *this;
  }
  T* operator->() const
  {
    return impl_->p;
  }
  T& operator*() const
  {
    return *(impl_->p);
  }
private:
  void Decrement()
  {
    if( --(impl_->refs) ==0)
    {
      delete impl_;
    }
  }

  void Increment()
  {
    ++(impl_->refs);
  }
};

int main()
{
  int *a = new int[2];
  
  CountedPtr<int> intPtr(a);


  return 0;
}

[출처] 스마트



'Programing > C++' 카테고리의 다른 글

CUDA 메모리 접근  (0) 2016.12.01
이중연결리스트.h  (0) 2016.11.30
가상함수테이블  (0) 2016.11.30
템플릿(Template) -클래스 템플릿, 템플릿의 특수화  (0) 2016.11.30
템플릿(Template) - 함수 템플릿, 클래스 템플릿, 템플릿의 특수화  (0) 2016.11.30



#include


 <iostream>

using namespace std;


class Parent

{

        int x;

public:

        virtual void foo() { cout <<" Parent::foo" << endl;}

};

 

class Child : public Parent

{

        int y;

public:

        virtual void foo() { cout << "child::foo"<< endl; }  

        // 가상함수는inline 될수없다. inline : 컴파일시수행.  가상함수: 실행시간수행

};

 

int main()

{

        Parent p;

        cout << sizeof(p) << endl;   // p 는4바이트가아니고8바이트(가상함수테이블포인터추가)

 

        Child c;

        cout<< sizeof(c) << endl;   // x,y까지8바이트+ 가상함수테이블포인터4바이트= 12바이트

 

        Parent* pc = &c;

        pc->foo();    

      // (*pc)[0]()의기계어코드를만들어낸다.이게 포인트다. 이름을 보지 않고 배열의 인덱스로 함수를 

      // 찾아간다. 이걸 기억해두고 아래 문제를 생각한다. 결국 이 코드는

      // 가상함수테이블의첫번째공간으로..어디로 갈지 실행시간에(vptr을 보고) 결정된다

}

 

 

 

 

 

class A

{

        int x;

public:

        virtual void foo() { cout << "A::foo" << endl; }

};

 

class B       // A와상속관계가아님

{

        int y;

public:

        virtual void goo() { cout << "B::goo" << endl; }

};

 

int main()

{

        A a;

        B* p = (B*)&a;

 

        p->goo();   // 둘다가상함수가아니라면B:goo() 가실행된다.

}

 

// foo와goo 가둘다가상함수라면foo()가호출.

// (코드에서타입은B* 이지만&a가대입되어a의주소를가진다.따라서가상함수테이블도A의그것으로가진다.

 

// 런타임시간에p->goo 는B의goo 가있는줄알고가상함수테이블을따라가서(첫번째로간다) 그곳을참조하는데가보니까

//  A::foo 가있어서호출해버린다-_-.. 배열인덱스처럼따라간다.)

// foo 가 가상이고 goo가 가상이 아니라면 goo()가호출. A는 vptr이 있지만 B는 vptr이 없다. 그래서 A를 대입해도 B는 테이블을 안만든다. 그래서 그냥 goo로..

// goo 가 가상이 아니고 goo가 가상이라면 에러.(쓰레기값을참조한다) A 함수에는 vptr이 없다고!

 

 

class A

{

public:

        virtual void foo() { cout << "A::foo" << endl; }

};

 

class B : public A

{

public :

        virtual void foo() { cout << " B:: foo " << endl; }

};

 

void hoo(A* p, A& r, A o)

{

        p->foo();     // B::foo

        r.foo();      // B::foo

        o.foo();  // 값으로전달받는다. A::foo

}

 

int main()

{

        B b;

        hoo(&b,b,b);

}




클래스에 가상 함수가 포함되면 클래스 멤버에 vptr이라는 포인터가 추가된다. 코드에는 나타나지 않고 디버그중에 조사식으로 확

인할 수 있다. vptr은 해당 클래스의 가상함수 테이블의 주소를 가지고 있다. 해당 클래스의 virtual 선언에 따라 클래스가 실행해야

할 가상함수의 함수포인터가 배열을 이루고 있음을 확인할 수 있다. 이것을 가상 함수 테이블이라 한다.

'Programing > C++' 카테고리의 다른 글

이중연결리스트.h  (0) 2016.11.30
스마트 포인터  (0) 2016.11.30
템플릿(Template) -클래스 템플릿, 템플릿의 특수화  (0) 2016.11.30
템플릿(Template) - 함수 템플릿, 클래스 템플릿, 템플릿의 특수화  (0) 2016.11.30
클래스  (0) 2016.11.30

#클래스 템플릿(class template)

템플릿은 컴파일시 내부적으로 템플릿 인자로 넘어온 자료형을 적용하여 새로운 클래스를 하나 생성하게 된다. 그리고 컴파일러는 생성한 클래스를 가지고 작업을 수행하게 된다. 템플릿 클래스는 선언시 자료형에 상관없는 범용클래스로 만든후 객체 생성시 자료형을 지정해주면, 지정한 자료형에 맞는 클래스 인스턴스가 생성된다.

template <typename 식별자> 클래스 {  //클래스 정의

  //내용

};

template <typename 식별자>

void 클래스명<식별자>::멤버함수() {  // 맴버 함수 구현

  //내용

}

[출처] [C++]템플릿(Template) - 함수 템플릿, 클래스 템플릿, 템플릿의 특수화|작성자 제우스


//***************************************************************************
// 템플릿 클래스 !!
//***************************************************************************


#include <iostream>
using namespace std;
// 배열 추상화 !!
// 1) 속성!!
// --> Data buffer !!
// --> 배열의 길이
// 2) 행동 !!
// --> 입력
// --> 삭제
// --> 출력
template <typename T>
class Array
{
private :
T *m_Buf;
int m_size;
public :
Array()
{
cout << "최대 배열의 크기 입력 ";
cin >> m_size;
m_Buf = new int[sizeof(T)]();
//memset(m_Buf,0,40);//******************//
 menu();
}
~Array(){}
int & operator[](int idx)
{
return m_Buf[idx];
}
void push_back()
{
if(m_Buf[m_size-1] !=0){
m_Buf = (int *)realloc(m_Buf,_msize(m_Buf)+4);
m_size = _msize(m_Buf)/sizeof(int);
cout << "맨뒤에 넣을 값을 입력 ";
cin >> m_Buf[m_size-1];
}
else{
cout << "맨뒤에 넣을 값을 입력 ";
cin >> m_Buf[m_size-1];
}
}
void pop_back()
{
m_Buf[m_size-1] = 0;
cout << "["<< m_size << "]" << "맨뒤에 배열의 값을 뿅~~~~~" << endl;
m_Buf = (int *)realloc(m_Buf,_msize(m_Buf)-4);
m_size = _msize(m_Buf)/sizeof(int);
}
void push_front()
{
if(m_Buf[0] !=0){
m_Buf = (int *)realloc(m_Buf,_msize(m_Buf)+4);
m_size = _msize(m_Buf)/sizeof(int);
m_Buf[m_size-1] = 0;
for(int i=m_size;i>0;i--){
m_Buf[i-1] = m_Buf[i-2];
}
cout << "맨앞에 넣을 값을 입력 ";
cin >> m_Buf[0];
}
else{
cout << "맨앞에 넣을 값을 입력 ";
cin >> m_Buf[0];
}
}

void pop_front()
{
//cout << "맨앞에 배열의 값을 뿅~~~~~" << endl;
for(int i=0;i<m_size;i++){
  m_Buf[i] = m_Buf[i+1]; 
}
m_Buf = (int *)realloc(m_Buf,_msize(m_Buf)-4);
m_size = _msize(m_Buf)/sizeof(int);
cout << "["<< 0 << "]" << "맨앞에 배열의 값을 뿅~~~~~" << endl;
}
void Add()
{
int num=0;
cout << "몇번째 ?? " <<endl;
cin >> num;
if(m_Buf[num-1] !=0){
m_Buf = (int *)realloc(m_Buf,_msize(m_Buf)+4);
m_size = _msize(m_Buf)/sizeof(int);
m_Buf[m_size-1] = 0;
for(int i=m_size;i>num-2;i--){
  m_Buf[i-1] = m_Buf[i-2]; 
}
cout<< "숫자 입력 ";
cin >> m_Buf[num-1];
}
else{
cout<< "숫자 입력 ";
cin >> m_Buf[num -1];
}
}
void Pop_Select()
{
}

void Show()
{
for(int i=0;i<m_size;i++){
cout <<" "<< "["<< m_Buf[i] <<"]" ;
}
cout << endl;
}
void ascending_selection_sort ()    // 오름차순
{
cout << " 오름 차순 "<< endl;
int i, j, min;
for ( i = 0; i < m_size-1; i++ )
{
for ( min = i+1, j = i+2; j < m_size; j++ )
if ( m_Buf[min] > m_Buf[j] ) min = j;
  if ( m_Buf[min] < m_Buf[i] ){
  int t = m_Buf[i]; m_Buf[i] = m_Buf[min]; m_Buf[min] = t; 
 }
}
  Show();
} 
void descending_selection_sort ()    // 내림차순
{
cout << " 내림 차순 " << endl;
int i, j, max;
for ( i = 0; i <m_size-1; i++ )
{
for ( max = i+1, j = i+2; j < m_size; j++ )
if ( m_Buf[max] < m_Buf[j] ) max = j;
if ( m_Buf[max] > m_Buf[i] ) {
int t = m_Buf[i]; m_Buf[i] = m_Buf[max]; m_Buf[max] = t; 
}
}
Show();
}



int Modi()
{
int num=0;
system("cls");
cout << "[1] 배열추가" << endl;
cout << "[2] push_back" << endl;
cout << "[3] pop_back" << endl;
cout << "[4] push_front" << endl;
cout << "[5] pop_front" << endl;
cout << "[6] 배열사이꺼 뺴기 " << endl;
cout << "[7] show " << endl;
cout << "[8] 내림차순정렬" << endl;
cout << "[9] 오름차순정렬" << endl;
cout << "[0] 종 료" << endl;
cin >> num;

return num;
}
void menu()
{
int num=0;
while((num = Modi()) != 0)
{
switch(num)
{ 
case 1: Add(); break;
case 2:push_back(); break;
case 3:pop_back(); break;
case 4:push_front();break;
case 5:pop_front(); break;
case 6:Pop_Select(); break;
case 7:Show(); break;
case 8 :descending_selection_sort(); break;
case 9:ascending_selection_sort () ;break;
default : cout << "error" << endl;
}
system("PAUSE");
}
}
Array &operator ()(Array &ar)
{
//ar.Show();
return ar;
}
};

template <typename T>
ostream & operator <<(ostream & os, Array<T> &ar)
{
ar.Show();
return os;
}

 

// 단점
// 1) 정적인 배열의 크기 ==> 동적배열 !!
// 2) 인덱스를 통한 접근이 안됨 ==> 연산자 오버로딩 !!
// 3) 시작위치의 주소값을 같지 않는다 ==> 객체 출력자 구현 !!

void main()
{
Array<int> ar;
cout << ar << endl;
//ar.Show();
//ar.push_back();
}


'Programing > C++' 카테고리의 다른 글

스마트 포인터  (0) 2016.11.30
가상함수테이블  (0) 2016.11.30
템플릿(Template) - 함수 템플릿, 클래스 템플릿, 템플릿의 특수화  (0) 2016.11.30
클래스  (0) 2016.11.30
구조체  (0) 2016.11.30
[C++]템플릿(Template) - 함수 템플릿, 클래스 템플릿, 템플릿의 특수화
//*****************************************************************************
// 템플릿 (template)
//*****************************************************************************
// 일반화 프로그래밍
// 하나의 함수혹은 클래스에서 여러가지 경우를 모두 처리하는 프로그래밍 기법!
// 여러가지 경우라 함은 로직은 같지만 타입 때문에 여러개로 정의해야 하는 경우 

#템플릿이란?

기능은 결정되어 있으나 자료형이 정해져 있지 않는 것을 템플릿 이라고 한다. 예을 들어 계산기 프로그램의 덧셈 함수를 만들때 해당 자료형에 맞는 함수를 오버로딩해야 한다. 하지만 템플릿으로 만든 함수는 그럴 필요가 없이 하나의 함수로 모두 사용이 가능하다.

 

#함수 템플릿(Function Template)

template <typename 식별자> 함수()  // 함수 앞에 사용. 식별자는 자료형을 의미하는 것으로 적용할 자료형에 사용하면 된다.

참고사항> typename을 class 로 대체 가능하다.  ex> template <class T>

ex>

template <typename T>  // 두줄로 해도 상관 없다.

T Add(T a, T b)

{

  return a+b;

}

  int  p = Add(1,3);  // int형 4을 반환 한다.

  int  p = Add<int>(1,3);  // 명시적으로 <자료형>을 같이 써주어도 된다. 위와 동일하게 동작한다.

  double q = Add(1.1,3.3);  // double형 4.4을 반환한다.

  CString str1 = "abcd", str2 = "EFGH", str;

  str = Add(str1, str2);  // CString형 "abcdEFGH"를 반환 한다.

 

위와 같이 자료형은 다르지만 하나의 함수로 이것을 가능하게 해주는 것이 템플릿이다. 물론 자료형이 같다고 되는 건 아니다. 예로 char*의 경우 포인터끼리 + 한다면 우리가 원하는 값이 나오지 않을 것이다. 이때 사용하는 것이 템플릿 특수화이다. CString 의 경우에는 + 연산자오버로딩이  되어있기 때문에 가능하다.

[출처] [C++]템플릿(Template) - 함수 템플릿, 클래스 템플릿, 템플릿의 특수화|작성자 제우스


#include <iostream>
using namespace std;

template<class Any>
void Swap(Any &a,Any &b)
{
Any temp;
temp = a;
a = b;
b = temp;
}
template<class Any,class Any2>
void Swap(Any2 &a,Any &b)
{
Any2 temp;
temp = a;
a = b;
b = temp;
}
void main()
{
int x= 20,y=10;
cout << "befor int swap   " << "x =  " << x <<"  "<<"y =  "<< y << endl; 
Swap(x,y);
cout << "after int swap   " << "x =  " << x <<"  "<<"y =  "<< y << endl;
cout << endl;
char i = 'c',j='j';
cout << "befor char swap   " << "i =  " <<i << "  "<<"j =  "<< j << endl; 
Swap(i,j);
cout << "after char swap   " << "i =  " << i<<"  " <<"j =  "<< j << endl;
cout << endl;
double k=24.5,c=94.3;
cout << "befor double swap   " << "k =  " <<k << "  "<<"c =  "<< c << endl; 
Swap(k,c);
cout << "after double swap   " << "k =  " << k<<"  " <<"c =  "<< c << endl;
cout << endl;

double num1 =84.5;
int num2 = 50;
cout << "befor double swap   " << "num1 =  " <<num1 << "  "<<"num2 =  "<< num2 << endl; 
Swap(num1,num2);
cout << "after double swap   " << "num1 =  " << num1<<"  " <<"num2 =  "<< num2 << endl;
cout << endl;
}


'Programing > C++' 카테고리의 다른 글

가상함수테이블  (0) 2016.11.30
템플릿(Template) -클래스 템플릿, 템플릿의 특수화  (0) 2016.11.30
클래스  (0) 2016.11.30
구조체  (0) 2016.11.30
함수 오버로딩, SWAP  (0) 2016.11.30
#ifndef MYTIME
#define MYTIME
//****************************************************************************************
//클래스 선언
//****************************************************************************************
class Time
{
private:
int hours;
int min;
public:
Time();
Time(int h,int m = 0);
void AddMin(int m);
void AddHr(int h);
void Reset(int h = 0, int m =0);
Time operator+(const Time & t) const;
Time operator-(const Time & t) const;
Time operator*(const Time & t) const;
void Show() const;
}
#endif MYTIME

//****************************************************************************************
#include <iostream>
#include "ex2.h"

Time::Time()
{
Hours = minutes = 0;
}
Time ::Time(int h, int m )
{
hours =h;
min = m ;
}
void Time::AddMin(int m)
{
min += m;
hour += min/60;
mim %= 60;
}

void Time::AddHr(int h)
{
hours += h;
}

void Time::Reset(int h, int m)
{
hours = h;
min = m;
}

Time Time::operator +(const Time &t) const
{
Time sum;
sum.min = min +t.min;
sum.hours = hour + t.hours + sum.min / 60;
sum.min %= 60;
return sum;
}

Time Time::operator -(const Time &t) const
{
Time diff;
int tot1, tot2;
tot1 = t.min + 60 * t.hours;
tot2 = min + 60 * hours;

diff.min = (tot2 - tot1) % 60;
diff.hours = (tot2 - tot1) / 60;

return diff;
}

Time Time::operator *(const Time &t) const
{
Time result;
long totalmin = hours * mult * 60 + min * mult;
result.hours = totalmin / 60;
result.min = totalmin % 60;

return result;
}

void Time::Show() const
{
std::cout << hours << "시간," << min <<"분";
}
//****************************************************************************************
// main
#include <iostream>
#include "ex2.h"

void main()
{
using namespace std;

Time weeding(4, 35);
Time waxing(2,47);
Time total;
Time diff;
Time adjusted;

cout << "weeding time = ";
weeding.Show();
cout << endl;

cout << "waxing time =";
waxing.Show();
cout << endl;

cout << "total work time =";
total = weeding + waxing;
total.Show();
cout << endl;

diff = weeding - waxing;
cout << "weeding time - waxing time =";
diff.Show();
cout << endl;

adjusted = total * 1.5;
cout << "adjusted work time = ";
adjusted.Show();
cout << endl;
}


'Programing > C++' 카테고리의 다른 글

템플릿(Template) -클래스 템플릿, 템플릿의 특수화  (0) 2016.11.30
템플릿(Template) - 함수 템플릿, 클래스 템플릿, 템플릿의 특수화  (0) 2016.11.30
구조체  (0) 2016.11.30
함수 오버로딩, SWAP  (0) 2016.11.30
함수오버로딩  (0) 2016.11.30

+ Recent posts

티스토리툴바