이벤트 객체 생성

¡WSAEVENT WSACreateEvent()
￠성공 : 이벤트 객체 핸들 반환
￠실패 : WSA_INVALID_EVENT 반환
￠Ex) WSAEVENT event = WSACreateEvent();
￠
¡BOOL WSACloseEvent(WSAEVENT hEvent)
￠성공 : TRUE 반환
￠실패 : FALSE 반환
￠Ex) WSACloseEvent(app.eventarray[index]);

소켓과 이벤트 객체 연결

¡Int WSAEventSelect(

  SOCKET s,

 

  WSAEVENT hEventObject,

 

이벤트 객체의 신호상태 감지
¡DWORD WSAWaitForMultipleEvents(

  DWORD cEvents,

  const WSAEVENT* lphEvents,

  BOOL fWaitAll,

  DWORD dwTimeout,

  BOOL fAlertable

);

Ex)WSAWaitForMultipleEvents(app.socktotal, app.eventarray, FALSE, WSA_INFINITE, FALSE);

  long INetWorkEvents

  )

¡Ex) WSAEventSelect(sock, event, FD_ACCEPT);

구체적 네트워크 이벤트 알아내기
¡Int WSAEnumNetworkEvents(

  SOCKET s,

  WSAEVENT hEventObject,

  LPWSANETWROKEVENTS lpNetworkEvents

  )

Ex) WSAEnumNetworkEvents(app.sockarray[index],app.eventarray[index], &app.netevents);


첨부파일있음.


EventSelctClient.zip

EventSelectSvc.zip




'Programing > 소켓 프로그래밍' 카테고리의 다른 글

IOCP, Input Output Completion Port  (0) 2016.11.30
Overlapped I/O 모델  (0) 2016.11.30

/*****************************************************************************
*  ------------------------------- dlist.h --------------------------------  *
*****************************************************************************/
#ifndef DLIST_H
#define DLIST_H
#include <stdlib.h>
/*****************************************************************************
*  Define a structure for doubly-linked list elements.                       *
*****************************************************************************/
typedef struct DListElmt_ {
 void               *data;
 struct DListElmt_  *prev;
 struct DListElmt_  *next;
} DListElmt;
/*****************************************************************************
*  Define a structure for doubly-linked lists.                               *
*****************************************************************************/
typedef struct DList_ {
 int                size;
 int                (*match)(const void *key1, const void *key2);
 void               (*destroy)(void *data);
 DListElmt          *head;
 DListElmt          *tail;
} DList;
/*****************************************************************************
*  --------------------------- Public Interface ---------------------------  *
*****************************************************************************/
void dlist_init(DList *list, void (*destroy)(void *data));
void dlist_destroy(DList *list);
int dlist_ins_next(DList *list, DListElmt *element, const void *data);
int dlist_ins_prev(DList *list, DListElmt *element, const void *data);
int dlist_remove(DList *list, DListElmt *element, void **data);
#define dlist_size(list) ((list)->size)
#define dlist_head(list) ((list)->head)
#define dlist_tail(list) ((list)->tail)
#define dlist_is_head(element) ((element)->prev == NULL ? 1 : 0)
#define dlist_is_tail(element) ((element)->next == NULL ? 1 : 0)
#define dlist_data(element) ((element)->data)
#define dlist_next(element) ((element)->next)
#define dlist_prev(element) ((element)->prev)
#endif



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

CUDA 메모리 접근  (0) 2016.12.01
스마트 포인터  (0) 2016.11.30
가상함수테이블  (0) 2016.11.30
템플릿(Template) -클래스 템플릿, 템플릿의 특수화  (0) 2016.11.30
템플릿(Template) - 함수 템플릿, 클래스 템플릿, 템플릿의 특수화  (0) 2016.11.30

/*****************************************************************************
*  -------------------------------- list.c --------------------------------  *
*****************************************************************************/
#include <stdlib.h>
#include <string.h>
#include "list.h"
/*****************************************************************************
*  ------------------------------- list_init ------------------------------  *
****************************************************************************/
void list_init(List *list, void (*destroy)(void *data)) {
 /*****************************************************************************
 *  Initialize the list.                                                      *
 *****************************************************************************/
 list->size = 0;
 list->destroy = destroy;
 list->head = NULL;
 list->tail = NULL;
 return;
}
/*****************************************************************************
*  ----------------------------- list_destroy -----------------------------  *
*****************************************************************************/
void list_destroy(List *list) {
 void               *data;
 /*****************************************************************************
 *  Remove each element.                                                      *
 *****************************************************************************/
 while (list_size(list) > 0) {
  if (list_rem_next(list, NULL, (void **)&data) == 0 && list->destroy != NULL) {
   /***********************************************************************
   *  Call a user-defined function to free dynamically allocated data.    *
   ***********************************************************************/
   list->destroy(data);
  }
 }
 /*****************************************************************************
 *  No operations are allowed now, but clear the structure as a precaution.   *
 *****************************************************************************/
 memset(list, 0, sizeof(List));
 return;
}
/*****************************************************************************
*  ----------------------------- list_ins_next ----------------------------  *
*****************************************************************************/
int list_ins_next(List *list, ListElmt *element, const void *data) {
 ListElmt           *new_element;
 /*****************************************************************************
 *  Allocate storage for the element.                                         *
 *****************************************************************************/
 if ((new_element = (ListElmt *)malloc(sizeof(ListElmt))) == NULL)
  return -1;
 /*****************************************************************************
 *  Insert the element into the list.                                         *
 *****************************************************************************/
 new_element->data = (void *)data;
 if (element == NULL) {
  /**************************************************************************
  *  Handle insertion at the head of the list.                              *
  **************************************************************************/
  if (list_size(list) == 0)
   list->tail = new_element;
  new_element->next = list->head;
  list->head = new_element;
 }
 else {
  /**************************************************************************
  *  Handle insertion somewhere other than at the head.                     *
  **************************************************************************/
  if (element->next == NULL)
   list->tail = new_element;
  new_element->next = element->next;
  element->next = new_element;
 }
 /*****************************************************************************
 *  Adjust the size of the list to account for the inserted element.          *
 *****************************************************************************/
 list->size++;
 return 0;
}
/*****************************************************************************
*  ----------------------------- list_rem_next ----------------------------  *
*****************************************************************************/
int list_rem_next(List *list, ListElmt *element, void **data) {
 ListElmt           *old_element;
 /*****************************************************************************
 *  Do not allow removal from an empty list.                                  *
 *****************************************************************************/
 if (list_size(list) == 0)
  return -1;
 /*****************************************************************************
 *  Remove the element from the list.                                         *
 *****************************************************************************/
 if (element == NULL) {
  /**************************************************************************
  *  Handle removal from the head of the list.                              *
  **************************************************************************/
  *data = list->head->data;
  old_element = list->head;
  list->head = list->head->next;
  if (list_size(list) == 1)
   list->tail = NULL;
 }
 else {
  /**************************************************************************
  *  Handle removal from somewhere other than the head.                     *
  **************************************************************************/
  if (element->next == NULL)
   return -1;
  *data = element->next->data;
  old_element = element->next;
  element->next = element->next->next;
  if (element->next == NULL)
   list->tail = element;
 }
 /*****************************************************************************
 *  Free the storage allocated by the abstract data type.                     *
 *****************************************************************************/
 free(old_element);
 /*****************************************************************************
 *  Adjust the size of the list to account for the removed element.           *
 *****************************************************************************/
 list->size--;
 return 0;
}



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

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

/*****************************************************************************
*  -------------------------------- 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

+ Recent posts

티스토리툴바