The following code example is taken from the book
The C++ Standard Library - A Tutorial and Reference
by Nicolai M. Josuttis, Addison-Wesley, 1999
© CopyrightNicolai M. Josuttis 1999


// myalloc.hpp

#include
 <limits>

#include <iostream>

 

namespace MyLib {

       template <class T> class MyAlloc {

       public:

             // type definitions

             typedef T        value_type;

             typedef T*       pointer;

             typedef const T* const_pointer;

             typedef T&       reference;

             typedef const T& const_reference;

             typedef std::size_t    size_type;

             typedef std::ptrdiff_t difference_type;

 

             // rebind allocator to type U

             template <class U> struct rebind {

                    typedef MyAlloc<U> other;

             };

 

             // return address of values

             pointer address (reference value) const {

                    return &value;

             }

             const_pointer address (const_reference value) const {

                    return &value;

             }

 

             /* constructors and destructor

             * - nothing to do because the allocator has no state

             */

             MyAlloc() throw() { }

             MyAlloc(const MyAlloc&) throw() { }

             ~MyAlloc() throw() { }

             template <class U> MyAlloc (const MyAlloc<U>&) throw() {}

 

             // return maximum number of elements that can be allocated

             size_type max_size () const throw() {

                    return std::numeric_limits<std::size_t>::max() / sizeof(T);

             }

 

             // allocate but don't initialize num elements of type T

             pointer allocate (size_type num, const void* = 0) {

                    // print message and allocate memory with global new

                    std::cerr << "allocate " << num << " element(s)"

                           << " of size " << sizeof(T) << std::endl;

                    pointer ret = (pointer)(::operator new(num*sizeof(T)));

                    std::cerr << " allocated at: " << (void*)ret << std::endl;

                    return ret;

             }

 

             // initialize elements of allocated storage p with value value

             void construct (pointer p, const T& value) {

                    // initialize memory with placement new

                    new((void*)p)T(value);

             }

 

             // destroy elements of initialized storage p

             void destroy (pointer p) {

                    // destroy objects by calling their destructor

                    p->~T();

             }

 

             // deallocate storage p of deleted elements

             void deallocate (pointer p, size_type num) {

                    // print message and deallocate memory with global delete

                    std::cerr << "deallocate " << num << " element(s)"

                           << " of size " << sizeof(T)

                           << " at: " << (void*)p << std::endl;

                    ::operator delete((void*)p);

             }

       };

 

       // return that all specializations of this allocator are interchangeable

       template <class T1, class T2>

       bool operator== (const MyAlloc<T1>&, const MyAlloc<T2>&) throw() {

                    return true;

       }

       template <class T1, class T2>

       bool operator!= (const MyAlloc<T1>&, const MyAlloc<T2>&) throw() {

                    return false;

       }

}

 

// myalloc.cpp

#include
 <vector>

#include "myalloc.hpp"

 

int main()

{

       // create a vector, using MyAlloc<> as allocator

       std::vector<int,MyLib::MyAlloc<int> > v;

 

       // insert elements

       // - causes reallocations

       v.push_back(42);

       v.push_back(56);

       v.push_back(11);

       v.push_back(22);

       v.push_back(33);

       v.push_back(44);

}


저작자 표시 비영리 변경 금지
신고
크리에이티브 커먼즈 라이선스
Creative Commons License

Comment



공부도 할겸 C언어로 연결리스트 구현.... 그냥 입력은 맨 처음에 넣는 방법으로 했고... 간단하게 구현해서 코드 읽기도 어렵지 않고, 어떻게 생각하면 부족한 부분이 많은 코드...

연결 리스트 : 일정한 순설르 가지는 데이터 항목들을 표현한느 방법중 하나. 배열과 같은 순차적 표현방법과 달리 데이터 항목의 논리적인 순서만 유지되고 기억장소 내에서는 각 항목들의 임의의 위치를 가지도록 하는 자료구조.


#include <stdio.h>
#include <stdlib.h>
 
 
struct  Node {
    int data;
    Node* next;
};
 
void isnert_node(Node* node, int input_data)    {
 
    Node* newNode = (Node *)malloc(sizeof(Node));
    newNode-&gt;data = input_data;
   
    if(node-&gt;next == NULL)  newNode-&gt;next = NULL;
    else                    newNode-&gt;next = node-&gt;next;
 
    node-&gt;next = newNode;
}
   
 
void delete_node(Node* node, int delete_data)   {
    Node* tmp = (Node* )malloc(sizeof(Node));
    Node* tmp_prev = (Node*) malloc(sizeof(Node));
   
    tmp = node;
    tmp_prev = node;
   
    if(tmp-&gt;next == NULL)   {
        printf("no value ");
        return ;
    }
   
    while(1)    {
        if(tmp-&gt;next == NULL)   {
            printf("no search ");
            return;
        }
        tmp_prev = tmp;
        tmp = tmp-&gt;next;
       
        if(tmp-&gt;data == delete_data)    {
            tmp_prev-&gt;next = tmp-&gt;next;
            free(tmp);
            return ;
        }
    }
   
}
 
void display_node(Node* node)   {
    Node *tmp = node;
   
    printf("[start]");
   
    while(tmp != NULL)  {
        printf(" -&gt; [%d]", tmp-&gt;data);
       
        tmp = tmp-&gt;next;
    }
   
}
 
 
int main()
{
 
    Node* head = (Node* ) malloc(sizeof(Node));
   
    head-&gt;data = 0;
    head-&gt;next = NULL;
   
    int in;
    char _input;
   
    while(1)    {
        printf("[(i)nsert, (d)elete, (p)rint, (q)uit] : ");
        scanf("%c", &amp;_input);
        getchar(); // 엔터 입력
 
        if(_input == 'i')      {
            printf("input number : ");
            scanf("%d", &amp;in);
 
            getchar();
            isnert_node(head, in);
        }
        else if(_input == 'd')      {
            printf("delete number : ");
            scanf("%d", &amp;in);
            getchar();
 
            delete_node(head, in);
        }
        else if(_input == 'p')    display_node(head-&gt;next);
        else if(_input == 'q')    break;
        else                        printf("Invalid input.. ");
        printf(" ");
    }
   
    fflush(stdin);
    free(head);
 
    return 0;   
}


저작자 표시 비영리 변경 금지
신고
크리에이티브 커먼즈 라이선스
Creative Commons License

Comment

#include <iostream>

class A {
public:
    A() {    std::cout << "a create" << std::endl; }
    ~A()    {   std::cout << "a delete" << std::endl; }
};
class B  {
public: 
    B() {    std::cout << "b create" << std::endl; }
    ~B()    {   std::cout << "b delete" << std::endl; }
};
class C : public B {
public: 
    C() {    std::cout << "c create" << std::endl; }
    ~C()    {   std::cout << "c delete" << std::endl; }
};


int main()
{
    
    B* a;
    a = new C();
    
    delete a;
    
    return 0;
    
}
실행 결과
a create
b create
c create
b delete
a delete

기록용...


저작자 표시 비영리 변경 금지
신고
크리에이티브 커먼즈 라이선스
Creative Commons License

Comment



티스토리 툴바