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

template <typename T> class MemoryPool
{
public:
    MemoryPool(size_t size = EXPANSION_SIZE)
    {
        expandTheFreeList(size);
    }
    ~MemoryPool();
    //allocate a T element from the free list.
    void* alloc(size_t size)
    {
        if (next == NULL)
        {
            expandTheFreeList();
        }
        MemoryPool<T>* head = next;
        next = head->next;
        return head;
    }
    //return a T element to the free list.
    void free(void* doomed)
    {
        MemoryPool<T>* head = static_cast< MemoryPool<T>* > (doomed);
        head->next = next;
        next = head;
    }

private:
    //next element on the free list.
    MemoryPool<T>* next;
    //if the freelist is empty, expand it by this amount.
    enum {EXPANSION_SIZE = 32};
    //add free elements to the free list
    void expandTheFreeList(int howMany = EXPANSION_SIZE);
};

template <typename T> MemoryPool<T> :: ~MemoryPool()
{
    MemoryPool<T>* nextPtr = NULL;
    while (nextPtr)
    {
        nextPtr = next;
        next = next->next;
        delete [] nextPtr;
    }
}

template <typename T> void MemoryPool<T> :: expandTheFreeList(int howMany)
{
    //we must allocate an object enough to contain the next pointer
    size_t size = sizeof(T) > sizeof(MemoryPool<T>*) ? sizeof(T) :
                  sizeof(MemoryPool<T>*);

    MemoryPool<T>* runner = (MemoryPool<T>*) new char[size];
    next = runner;
    for (int i = 0; i < howMany; ++i)
    {
        runner->next = (MemoryPool<T>*) new char[size];
        runner = runner->next;
    }
    runner->next = NULL;
}

class ABClock //abstract base class
{
public:
    virtual ~ABClock() {}
    virtual void lock() = 0;
    virtual void unlock() = 0;
};

class MutexLock : public ABClock
{
public:
    MutexLock()
    {
        hMutex = CreateMutex(NULL, FALSE, NULL);
    }
    ~MutexLock()
    {
        CloseHandle(hMutex);
    }
    void lock()
    {
        WaitForSingleObject(hMutex, INFINITE);
    }
    void unlock()
    {
        ReleaseMutex(hMutex);
    }
private:
    HANDLE hMutex;
};

template <typename POOLTYPE, typename LOCK>
class MTMemoryPool
{
public:
    //allocate an element from the freelist.
    void* alloc(size_t size)
    {
        void* mem;
        theLock.lock();
        mem = stPool.alloc(size);
        theLock.unlock();
        return mem;
    }

    //return an element to the freelist
    void free(void* someElement)
    {
        theLock.lock();
        stPool.free(someElement);
        theLock.unlock();
    }

private:
    POOLTYPE stPool;//Single-threaded pool.
    LOCK theLock;
};

class Rational
{
public:
    Rational(int a = 0, int b = 1) : n(a), d(b) {}
    void* operator new(size_t size)
    {
        return memPool->alloc(size);
    }
    void operator delete(void* doomed, size_t size)
    {
        memPool->free(doomed);
    }
    static void newMemPool()
    {
        memPool = new MTMemoryPool< MemoryPool<Rational>, MutexLock>;
    }
    static void deleteMemPool()
    {
        delete memPool;
    }

private:
    int n;
    int d;
    static MTMemoryPool< MemoryPool<Rational>, MutexLock>* memPool;
};
MTMemoryPool< MemoryPool<Rational>, MutexLock>* Rational::memPool = NULL;

int main()
{
    const int ARRAY_SIZE = 1000;
    const int LOOP_TIMES = 5000;

    Rational* array[ARRAY_SIZE];
    clock_t beg = clock();
    Rational::newMemPool();
    for (int i = 0; i < LOOP_TIMES; ++i)
    {
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            array[j] = new Rational(j);
        }
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            delete array[j];
        }
    }
    clock_t end = clock();
    printf("use %f second(s).\n", 1.0 * (end - beg) / CLOCKS_PER_SEC);
    system("pause");
    Rational::deleteMemPool();

    return 0;
}

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

template <typename T> class MemoryPool
{
public:
    MemoryPool(size_t size = EXPANSION_SIZE)
    {
        expandTheFreeList(size);
    }
    ~MemoryPool();
    //allocate a T element from the free list.
    void* alloc(size_t size)
    {
        if (next == NULL)
        {
            expandTheFreeList();
        }
        MemoryPool<T>* head = next;
        next = head->next;
        return head;
    }
    //return a T element to the free list.
    void free(void* doomed)
    {
        MemoryPool<T>* head = static_cast< MemoryPool<T>* > (doomed);
        head->next = next;
        next = head;
    }

private:
    //next element on the free list.
    MemoryPool<T>* next;
    //if the freelist is empty, expand it by this amount.
    enum {EXPANSION_SIZE = 32};
    //add free elements to the free list
    void expandTheFreeList(int howMany = EXPANSION_SIZE);
};

template <typename T> MemoryPool<T> :: ~MemoryPool()
{
    MemoryPool<T>* nextPtr = NULL;
    while (nextPtr)
    {
        nextPtr = next;
        next = next->next;
        delete [] nextPtr;
    }
}

template <typename T> void MemoryPool<T> :: expandTheFreeList(int howMany)
{
    //we must allocate an object enough to contain the next pointer
    size_t size = sizeof(T) > sizeof(MemoryPool<T>*) ? sizeof(T) :
                  sizeof(MemoryPool<T>*);

    MemoryPool<T>* runner = (MemoryPool<T>*) new char[size];
    next = runner;
    for (int i = 0; i < howMany; ++i)
    {
        runner->next = (MemoryPool<T>*) new char[size];
        runner = runner->next;
    }
    runner->next = NULL;
}

class ABClock //abstract base class
{
public:
    virtual ~ABClock() {}
    virtual void lock() = 0;
    virtual void unlock() = 0;
};

class CriticalSectionLock : public ABClock
{
public:
    CriticalSectionLock()
    {
        InitializeCriticalSection(csMyCriticalSection);
    }
    ~CriticalSectionLock()
    {
        DeleteCriticalSection(csMyCriticalSection);
    }
    void lock()
    {
        EnterCriticalSection(csMyCriticalSection);
    }
    void unlock()
    {
        LeaveCriticalSection(csMyCriticalSection);
    }
private:
    CRITICAL_SECTION csMyCriticalSection;
};

template <typename POOLTYPE, typename LOCK>
class MTMemoryPool
{
public:
    //allocate an element from the freelist.
    void* alloc(size_t size)
    {
        void* mem;
        theLock.lock();
        mem = stPool.alloc(size);
        theLock.unlock();
        return mem;
    }

    //return an element to the freelist
    void free(void* someElement)
    {
        theLock.lock();
        stPool.free(someElement);
        theLock.unlock();
    }

private:
    POOLTYPE stPool;//Single-threaded pool.
    LOCK theLock;
};

class Rational
{
public:
    Rational(int a = 0, int b = 1) : n(a), d(b) {}
    void* operator new(size_t size)
    {
        return memPool->alloc(size);
    }
    void operator delete(void* doomed, size_t size)
    {
        memPool->free(doomed);
    }
    static void newMemPool()
    {
        memPool = new MTMemoryPool< MemoryPool<Rational>, CriticalSectionLock>;
    }
    static void deleteMemPool()
    {
        delete memPool;
    }

private:
    int n;
    int d;
    static MTMemoryPool< MemoryPool<Rational>, CriticalSectionLock>* memPool;
};
MTMemoryPool< MemoryPool<Rational>, CriticalSectionLock>* Rational::memPool = NULL;

int main()
{
    const int ARRAY_SIZE = 1000;
    const int LOOP_TIMES = 5000;

    Rational* array[ARRAY_SIZE];
    clock_t beg = clock();
    Rational::newMemPool();
    for (int i = 0; i < LOOP_TIMES; ++i)
    {
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            array[j] = new Rational(j);
        }
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            delete array[j];
        }
    }
    clock_t end = clock();
    printf("use %f second(s).\n", 1.0 * (end - beg) / CLOCKS_PER_SEC);
    system("pause");
    Rational::deleteMemPool();

    return 0;
}

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

class MemoryChunk
{
public:
    MemoryChunk(MemoryChunk* nextChunk, size_t reqSize)
    {
        chunkSize = reqSize > DEFAULT_CHUNK_SIZE ? reqSize :
                    DEFAULT_CHUNK_SIZE;
        next = nextChunk;
        byteAlreadyAllocated = 0;
        mem = new char[chunkSize];
    }

    ~MemoryChunk()
    {
        delete [] mem;
    }

    void* alloc(size_t size)
    {
        void* addr = (void*)(mem + byteAlreadyAllocated);
        byteAlreadyAllocated += size;
        return addr;
    }

    //不需要释放内存块
    void free(void* doomed)
    {

    }

    MemoryChunk* nextMemChunk() { return next; }
    size_t spaceAvailable()
    {
        return chunkSize - byteAlreadyAllocated;
    }
    enum {DEFAULT_CHUNK_SIZE = 4096};
private:
    MemoryChunk* next;//下一个内存块
    char* mem;//该内存块地址
    size_t chunkSize; //该内存块的大小
    size_t byteAlreadyAllocated;//该内存块被申请使用的大小
};

class ByteMemoryPool
{
public:
    ByteMemoryPool(size_t initSize = MemoryChunk::DEFAULT_CHUNK_SIZE)
    {
        expandStorage(initSize);
    }
    ~ByteMemoryPool();

    void* alloc(size_t reqSize)
    {
        size_t space = listOfMemoryChunks->spaceAvailable();
        if (space < reqSize)
        {
            expandStorage(reqSize);
        }
        return listOfMemoryChunks->alloc(reqSize);
    }

    void free(void* doomed)
    {
        listOfMemoryChunks->free(doomed);
    }

private:
    void expandStorage(size_t reqSize)
    {
        listOfMemoryChunks = new MemoryChunk(listOfMemoryChunks, reqSize);
    }
    MemoryChunk* listOfMemoryChunks;
};

ByteMemoryPool::~ByteMemoryPool()
{
    MemoryChunk* memChunk = listOfMemoryChunks;
    while (memChunk)
    {
        listOfMemoryChunks = memChunk->nextMemChunk();
        delete memChunk;
        memChunk = listOfMemoryChunks;
    }
}

class Rational
{
public:
    Rational(int a = 0, int b = 1) : n(a), d(b) {}
    void* operator new(size_t size) {return memPool->alloc(size);}
    void operator delete(void* doomed, size_t size) {/*memPool->free(doomed);*/}
    static void newMemPool() {memPool = new ByteMemoryPool;}
    static void deleteMemPool() {delete memPool;}

private:
    int n;
    int d;
    static ByteMemoryPool* memPool;
};
ByteMemoryPool* Rational::memPool = NULL;

int main()
{
    const int ARRAY_SIZE = 1000;
    const int LOOP_TIMES = 5000;

    Rational* array[ARRAY_SIZE];
    clock_t beg = clock();
    Rational::newMemPool();
    for (int i = 0; i < LOOP_TIMES; ++i)
    {
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            array[j] = new Rational(j);
        }
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            delete array[j];
        }
    }
    clock_t end = clock();
    printf("use %f second(s).\n", 1.0 * (end - beg) / CLOCKS_PER_SEC);
    system("pause");
    Rational::deleteMemPool();

    return 0;
}

#include
#include
#include

class Rational
{
public:
    Rational(int a = 0, int b = 1) : n(a), d(b) {}

private:
    int n; // Numerator
    int d; // Denominator
};

int main()
{
    const int ARRAY_SIZE = 1000;
    const int LOOP_TIMES = 5000;
    Rational* array[ARRAY_SIZE];

    clock_t beg = clock();
    for (int i = 0; i < LOOP_TIMES; ++i)
    {
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            array[j] = new Rational(j);
        }
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            delete array[j];
        }
    }
    clock_t end = clock();
    printf("use %f second(s).\n", 1.0 * (end - beg) / CLOCKS_PER_SEC);
    system("pause");

    return 0;
}

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

struct NextOnFreeList
{
    NextOnFreeList* next;
};

class Rational
{
public:
    Rational(int a = 0, int b = 1) : n(a), d(b) {}

    void* operator new(size_t size)
    {
        if (freeList == 0)// if the list is empty, fill it up.
        {
            expandTheFreeList();
        }

        NextOnFreeList* head = freeList;
        freeList = head->next;
        return head;
    }

    void operator delete(void* doomed, size_t size)
    {
        NextOnFreeList* head = static_cast<NextOnFreeList*> (doomed);
        head->next = freeList;
        freeList = head;
    }
    static void newMemPool()
    {
        expandTheFreeList();
    }
    static void deleteMemPool();

private:
    static void expandTheFreeList();
    static NextOnFreeList* freeList;
    enum { EXPANSION_SIZE = 32 };
    int n; // Numerator
    int d; // Denominator
};

NextOnFreeList* Rational::freeList = NULL;

//当空闲列表里面没有对象时，该函数才会被调用
void Rational::expandTheFreeList()
{
    size_t size = sizeof(Rational) > sizeof(NextOnFreeList*) ?
                  sizeof(Rational) : sizeof(NextOnFreeList*);
    NextOnFreeList* runner = (NextOnFreeList*)new char[size];
    freeList = runner;
    for (int i = 0; i < EXPANSION_SIZE; ++i)
    {
        runner->next = (NextOnFreeList*)new char[size];
        runner = runner->next;
    }
    runner->next = 0;
}

void Rational::deleteMemPool()
{
    NextOnFreeList* nextPtr = freeList;
    while (nextPtr)
    {
        freeList = nextPtr->next;
        delete [] nextPtr;
        nextPtr = freeList;
    }
}

int main()
{
    const int ARRAY_SIZE = 1000;
    const int LOOP_TIMES = 5000;
    Rational* array[ARRAY_SIZE];

    clock_t beg = clock();
    Rational::newMemPool();
    for (int i = 0; i < LOOP_TIMES; ++i)
    {
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            array[j] = new Rational(j);
        }
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            delete array[j];
        }
    }
    clock_t end = clock();
    printf("use %f second(s).\n", 1.0 * (end - beg) / CLOCKS_PER_SEC);
    system("pause");
    Rational::deleteMemPool();

    return 0;
}

#include
#include
#include

template  class MemoryPool
{
public:
    MemoryPool(size_t size = EXPANSION_SIZE)
    {
        expandTheFreeList(size);
    }
    ~MemoryPool();
    //allocate a T element from the free list.
    void* alloc(size_t size)
    {
        if (next == NULL)
        {
            expandTheFreeList();
        }
        MemoryPool* head = next;
        next = head->next;
        return head;
    }
    //return a T element to the free list.
    void free(void* doomed)
    {
        MemoryPool* head = static_cast< MemoryPool* > (doomed);
        head->next = next;
        next = head;
    }

private:
    //next element on the free list.
    MemoryPool* next;
    //if the freelist is empty, expand it by this amount.
    enum {EXPANSION_SIZE = 32};
    //add free elements to the free list
    void expandTheFreeList(int howMany = EXPANSION_SIZE);
};

template  MemoryPool :: ~MemoryPool()
{
    MemoryPool* nextPtr = NULL;
    while (nextPtr)
    {
        nextPtr = next;
        next = next->next;
        delete [] nextPtr;
    }
}

template  void MemoryPool :: expandTheFreeList(int howMany)
{
    //we must allocate an object enough to contain the next pointer
    size_t size = sizeof(T) > sizeof(MemoryPool*) ? sizeof(T) :
                  sizeof(MemoryPool*);

    MemoryPool* runner = (MemoryPool*) new char[size];
    next = runner;
    for (int i = 0; i < howMany; ++i)     {         runner->next = (MemoryPool*) new char[size];
        runner = runner->next;
    }
    runner->next = NULL;
}

class Rational
{
public:
    Rational(int a = 0, int b = 1) : n(a), d(b) {}
    void* operator new(size_t size) {return memPool->alloc(size);}
    void operator delete(void* doomed, size_t size) {memPool->free(doomed);}
    static void newMemPool() {memPool = new MemoryPool;}
    static void deleteMemPool() {delete memPool;}

private:
    int n;
    int d;
    static MemoryPool* memPool;
};
MemoryPool* Rational::memPool = NULL;

int main()
{
    const int ARRAY_SIZE = 1000;
    const int LOOP_TIMES = 5000;
    Rational* array[ARRAY_SIZE];

    clock_t beg = clock();
    Rational::newMemPool();
    for (int i = 0; i < LOOP_TIMES; ++i)
    {
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            array[j] = new Rational(j);
        }
        for (int j = 0; j < ARRAY_SIZE; ++j)
        {
            delete array[j];
        }
    }
    clock_t end = clock();
    printf("use %f second(s).\n", 1.0 * (end - beg) / CLOCKS_PER_SEC);
    system("pause");
    Rational::deleteMemPool();

    return 0;
}

#include <windows.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glut.h>
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")

const int WINDOW_WIDTH = 640;
const int WINDOW_HEIGHT = 480;
const int WINDOW_POS_X = 300;
const int WINDOW_POS_Y = 150;

void myInit()
{
    glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
    glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
}

//draw a z-axis, with cone at end
void axis(double length)
{
    glPushMatrix();
    glBegin(GL_LINES);
    glVertex3d(0, 0, 0);
    glVertex3d(0, 0, length);
    glEnd();
    glTranslated(0, 0, length - 0.2);//平移
    glutWireCone(0.04, 0.2, 12, 9);
    glPopMatrix();
}

void displayWire()
{
    glMatrixMode(GL_PROJECTION);//设置视景体
    glLoadIdentity();
    glOrtho(-2.0 * 64 / 48, 2.0 * 64 / 48, -2.0, 2.0, 0.1, 100);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(1.0, 1.0, 2.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

    glClear(GL_COLOR_BUFFER_BIT);
    glColor3d(0, 0, 0);

    axis(0.5);//z-axis
    glPushMatrix();
    glRotated(-90, 1.0, 0, 0);
    axis(0.5);//y-axis
    glRotated(90.0, 0, 1.0, 0);
    axis(0.5);//x-axis
    glPopMatrix();

    glPushMatrix();
    glTranslated(0.5, 0.5, 0.5);
    glutWireCube(1.0);//线框立方体
    glPopMatrix();

    glColor3d(1.0, 0, 0);
    glPushMatrix();
    glTranslated(1.0, 1.0, 0);
    glutWireSphere(0.25, 10, 8);//线框球体
    glPopMatrix();

    glColor3d(0, 1.0, 0);
    glPushMatrix();
    glTranslated(1.0, 0, 1.0);
    glutWireCone(0.2, 0.5, 10, 8);//线框圆锥体
    glPopMatrix();

    glColor3d(0, 0, 1.0);
    glPushMatrix();
    glTranslated(1.0, 1.0, 1.0);
    glutWireTeapot(0.2);//线框茶壶
    glPopMatrix();

    glColor3d(1.0, 0, 1.00);
    glPushMatrix();
    glTranslated(0, 1.0, 0);
    glutWireTorus(0.1, 0.3, 10, 10);//线框花环
    glPopMatrix();

    glColor3d(0, 1.0, 1.0);
    glPushMatrix();
    glTranslated(1.0, 0, 0);
    glScaled(0.15, 0.15, 0.15);
    glutWireDodecahedron();//线框12面体
    glPopMatrix();

    glColor3d(0.1, 0.5, 0.2);
    glPushMatrix();
    glTranslated(0, 1.0, 1.0);
    glutWireCube(0.25);
    glPopMatrix();

    glPushMatrix();
    glTranslated(0, 0, 1.0);
    GLUquadricObj* qobj = gluNewQuadric();//创建二次曲面对象
    gluQuadricDrawStyle(qobj, GLU_LINE);
    glColor3d(0.3, 0.5, 0.4);
    gluCylinder(qobj, 0.2, 0.2, 0.4, 8, 8);//圆柱体
    glPopMatrix();
    glFlush();
}

int main(int argc, char** argv)
{
    glutInit(argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    glutInitWindowPosition(WINDOW_POS_X, WINDOW_POS_Y);
    glutCreateWindow("Transformation Test -Wireframes");
    glutDisplayFunc(displayWire);
    myInit();
    glutMainLoop();//进入消息循环

    return 0;
}

#include
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glut.h>
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")

const int WINDOW_WIDTH = 640;
const int WINDOW_HEIGHT = 480;
const int WINDOW_POS_X = 300;
const int WINDOW_POS_Y = 150;

void myInit()
{
    glEnable(GL_LIGHTING);//enable the light source
    glEnable(GL_LIGHT0);
    glShadeModel(GL_SMOOTH);//光滑着色
    glEnable(GL_DEPTH_TEST);//启用深度测试,根据坐标的远近自动隐藏被遮住的图形
    glEnable(GL_NORMALIZE);//根据函数glNormal的设置条件，启用法向量
    glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
    glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
}

//draw thin wall with top = xz-plane, corner at origin
void wall(double thickness)
{
    glPushMatrix();
    glTranslated(0.5, 0.5 * thickness, 0.5);
    glScaled(1.0, thickness, 1.0);
    glutSolidCube(1.0);
    glPopMatrix();
}

//table leg
void tableLeg(double thick, double len)
{
    glPushMatrix();
    glTranslated(0, len / 2, 0);
    glScaled(thick, len, thick);
    glutSolidCube(1.0);
    glPopMatrix();
}

//draw one axis of the unit jack-a stretched sphere
void jackPart()
{
    glPushMatrix();
    glScaled(0.2, 0.2, 1.0);
    glutSolidSphere(1, 15, 15);
    glPopMatrix();

    glPushMatrix();
    glTranslated(0, 0, 1.2);//ball on one end
    glutSolidSphere(0.2, 15, 15);
    glTranslated(0, 0, -2.4);
    glutSolidSphere(0.2, 15, 15);//ball on the other end
    glPopMatrix();
}

//draw a unit jact out of spheroids
void jack()
{
    glPushMatrix();
    jackPart();
    glRotated(90.0, 0, 1, 0);
    jackPart();
    glRotated(90.0, 1.0, 0, 0);
    jackPart();
    glPopMatrix();
}

//draw the table - a top and four legs
//绘画桌子时候，外部调用已经使原点到达桌子中间了
void table(double topWid, double topThick, double legThick, double legLen)
{
    glPushMatrix();
    glTranslated(0, legLen, 0);
    glScaled(topWid, topThick, topWid);
    glutSolidCube(1.0);//桌面
    glPopMatrix();

    double dist = 0.95 * topWid / 2.0 - legThick / 2.0;
    glPushMatrix();
    //glTranslated(dist, 0, dist);
    glTranslated(dist, 0, dist);
    tableLeg(legThick, legLen);
    glTranslated(0, 0, -2 * dist);
    tableLeg(legThick, legLen);
    glTranslated(-2 * dist, 0, 2 * dist);
    tableLeg(legThick, legLen);
    glTranslated(0, 0, -2 * dist);
    tableLeg(legThick, legLen);
    glPopMatrix();
}

void displaySolid()
{
    //设置表面纹理属性
    GLfloat mat_ambient[] = {0.7, 0.7, 0.7, 1.0};
    GLfloat mat_diffuse[] = {0.6, 0.6, 0.6, 1.0};
    GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0};//反射
    GLfloat mat_shininess[] = {50.0};//光

    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);//环境光材质
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);//漫反射
    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);//镜面反射
    glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);//光亮

    //设置光源属性
    GLfloat lightIntensity[] = {0.7, 0.7, 0.7, 1.0};
    GLfloat lightPosition[] = {2.0, 6.0, 3.0, 0.0};
    glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);//设置光源0的位置
    glLightfv(GL_LIGHT0, GL_DIFFUSE, lightIntensity);//光源漫反射强度的RGBA值

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    double winHt = 1.0; // half - height of th window
    glOrtho(-winHt * 64 / 48.0, winHt * 64 / 48.0, -winHt, winHt, 0.1, 100.0);

    glMatrixMode(GL_MODELVIEW);//设置照相机
    glLoadIdentity();
    gluLookAt(2.3, 1.3, 2, 0, 0.25, 0, 0.0, 1.0, 0.0);

    //start draw
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glPushMatrix();
    glTranslated(0.4, 0.4, 0.6);
    glRotated(45, 0, 0, 1);
    glScaled(0.08, 0.08, 0.08);
    jack();//draw the jack
    glPopMatrix();

    glPushMatrix();
    glTranslated(0.6, 0.38, 0.5);
    glRotated(30, 0, 1, 0);
    glutSolidTeapot(0.08);//draw the teapot
    glPopMatrix();

    glPushMatrix();
    glTranslated(0.25, 0.42, 0.35);
    glutSolidSphere(0.1, 15, 15);//draw the sphere
    glPopMatrix();

    glPushMatrix();
    glTranslated(0.4, 0, 0.4);
    table(0.6, 0.02, 0.02, 0.3);//draw the table
    glPopMatrix();

    wall(0.02); //wall #1: in xz-plane
    glPushMatrix();
    glRotated(90.0, 0.0, 0.0, 1.0);
    wall(0.02);//wall #2: in xy-plane
    glRotated(90.0, 1.0, 0.0, 0.0);
    wall(0.02);
    glPopMatrix();//wall #3: in yz-plane

    glFlush();
}

int main(int argc, char** argv)
{
    glutInit(argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    glutInitWindowPosition(WINDOW_POS_X, WINDOW_POS_Y);
    glutCreateWindow("Shaded example-3D scene");
    glutDisplayFunc(displaySolid);
    myInit();
    glutMainLoop();//进入消息循环

    return 0;
}

#include <stdio.h>

class CA
{
    public:
        CA(int nS = 100): nSize(nS)
        {
            nA = new int[nSize];
            printf("构造CA\n");
        }
        virtual ~CA()
        {
            delete [] nA;
            printf("析构CA\n");
        }

    private:
        int* nA;
        int nSize;
};

class CB : public CA
{
    public:
        CB(int nS = 100): nSize(nS)
        {
            nB = new int[nSize];
            printf("构造CB\n");
        }
        ~CB()
        {
            delete [] nB;
            printf("析构CB\n");
        }

    private:
        int* nB;
        int nSize;
};

int main()
{
    CA* pCA = new CB();
    delete pCA;
}

#include <windows.h>
#include <math.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glut.h>
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")

const float PI = atan(1.0) * 4;
const int WINDOW_WIDTH = 640;
const int WINDOW_HEIGHT = 480;
const int WINDOW_POS_X = 300;
const int WINDOW_POS_Y = 150;

//设置世界窗口
void SetWindow(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top)
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(left, right, bottom, top);
}

//设置视口
void SetViewport(GLint left, GLint right, GLint bottom, GLint top)
{
    glViewport(left, bottom, right - left, top - bottom);
}

void myInit()
{
    glClearColor(1.0, 1.0, 1.0, 0.0);//白色背景
    glColor3f(0.0, 0.0, 1.0);
    glLineWidth(2.0);
}

void myDisplay()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);//使视图矩形栈有效
    glLoadIdentity();

    SetViewport(0, WINDOW_WIDTH / 2, 0, WINDOW_HEIGHT);//这个函数调用在main里面一直没效果
    glBegin(GL_LINE_STRIP);
    for (float x = -4.0; x <= 4.0; x += 0.1)
    {
        if (fabs(x) < 1e-8)
        {
            glVertex2f(0.0, 1.0);
        }
        else
        {
            glVertex2f(x, sin(PI * x) / (PI* x));
        }
    }
    glEnd();

    glFlush();
}

int main(int argc, char** argv)
{
    glutInit(argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);//设置显示模式
    glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    glutInitWindowPosition(WINDOW_POS_X, WINDOW_POS_Y);
    glutCreateWindow("The Famous Sinc Function");
    glutDisplayFunc(myDisplay);
    myInit();
    SetWindow(-5.0, 5.0, -0.3, 1.0);
    glutMainLoop();//进入消息循环

    return 0;
}

#include <windows.h>
#include <math.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glut.h>
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")

const float PI = atan(1.0) * 4;
int nWidth = 640;
int nHeight = 480;
const int WINDOW_POS_X = 300;
const int WINDOW_POS_Y = 150;

//设置世界窗口
void SetWindow(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top)
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(left, right, bottom, top);
}

//设置视口
void SetViewport(GLint left, GLint right, GLint bottom, GLint top)
{
    glViewport(left, bottom, right - left, top - bottom);
}

void myInit()
{
    glClearColor(1.0, 1.0, 1.0, 0.0);//白色背景
    glColor3f(0.0, 0.0, 1.0);
    glLineWidth(2.0);
}

/////////////////////////////////////////////////////////////////
// Function: hexswirl()
// This draws a hexagon on the screen many times.  Each new
// hexagon is slightly bigger than the previous one and rotated
// slightly so that a hexagon "swirl" is drawn.
/////////////////////////////////////////////////////////////////
void hexSwirl()
{
    double angle;                       //the angle of rotation
    double angleInc = 2*3.14159265/6.0; //the angle increment
    double inc = 5.0 / 100;               //the radius increment
    double radius = 5.0 / 100.0;          //the radius to be used

    //glMatrixMode(GL_MODELVIEW);
    //glLoadIdentity();
    //clear the background

    //draw the hexagon swirl
    for (int j = 0; j <= 100; j++)
    {
        //the angle of rotation depends on which hexagon is 
        //being drawn.
        angle = j* (3.14159265/180.0);

        //draw one hexagon
        glBegin (GL_LINE_STRIP);
        for (int k=0; k <= 6; k++)
        {
            angle += angleInc;
            glVertex2d(radius * cos(angle), radius *sin(angle));

        }
        glEnd();

        //determine the radius of the next hexagon
        radius += inc;
    }

    //swap buffers for a smooth change from one
    //frame to another
    glutSwapBuffers();
    glFlush();
}

void myDisplay()
{
    glClear(GL_COLOR_BUFFER_BIT);
    float cx = 0.3, cy = 0.2;
    float H, W, aspect = 0.7;

    int frame = 50;
    for (int i = 0; i < frame; ++i)
    {
        glClear(GL_COLOR_BUFFER_BIT);
        W *= 0.7;
        H = W * aspect;
        SetWindow(cx - W, cx + W, cy - H, cy + H);
        hexSwirl();
    }

    glFlush();
}

void reShape(int nNewWidth, int nNewHeight)
{
    nWidth = nNewWidth;
    nHeight = nNewHeight;
    SetViewport(0, nWidth, 0, nHeight);
}

int main(int argc, char** argv)
{
    glutInit(argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);//设置显示模式
    glutInitWindowSize(nWidth, nHeight);
    glutInitWindowPosition(WINDOW_POS_X, WINDOW_POS_Y);
    glutCreateWindow("hexSwirl");
    glutDisplayFunc(myDisplay);
    glutReshapeFunc(reShape);
    myInit();
    glutMainLoop();//进入消息循环

    return 0;
}

#include <windows.h>
#include <math.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glut.h>
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")

const float PI = atan(1.0) * 4;
int nWidth = 640;
int nHeight = 480;
const int WINDOW_POS_X = 300;
const int WINDOW_POS_Y = 150;
const int ROW = 8;
const int COLUMU = 6;

//设置世界窗口
void SetWindow(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top)
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(left, right, bottom, top);
}

//设置视口
void SetViewport(GLint left, GLint right, GLint bottom, GLint top)
{
    glViewport(left, bottom, right - left, top - bottom);
}

void myInit()
{
    glClearColor(1.0, 1.0, 1.0, 0.0);//白色背景
    glColor3f(0.0, 0.0, 1.0);
    glLineWidth(2.0);
}

/////////////////////////////////////////////////////////////////
// Function: hexswirl()
// This draws a hexagon on the screen many times.  Each new
// hexagon is slightly bigger than the previous one and rotated
// slightly so that a hexagon "swirl" is drawn.
/////////////////////////////////////////////////////////////////
void hexSwirl()
{
    double angle;                       //the angle of rotation
    double angleInc = 2*3.14159265/6.0; //the angle increment
    double inc = 5.0 / 100;               //the radius increment
    double radius = 5.0 / 100.0;          //the radius to be used

    //glMatrixMode(GL_MODELVIEW);
    //glLoadIdentity();
    //clear the background

    //draw the hexagon swirl
    for (int j = 0; j <= 100; j++)
    {
        //the angle of rotation depends on which hexagon is 
        //being drawn.
        angle = j* (3.14159265/180.0);

        //draw one hexagon
        glBegin (GL_LINE_STRIP);
        for (int k=0; k <= 6; k++)
        {
            angle += angleInc;
            glVertex2d(radius * cos(angle), radius *sin(angle));

        }
        glEnd();

        //determine the radius of the next hexagon
        radius += inc;
    }
}

void myDisplay()
{
    glClear(GL_COLOR_BUFFER_BIT);

    const int  L = nWidth / ROW;

    for (int i = 0; i < ROW; ++i)
    {
        for (int j = 0; j < COLUMU; ++j)
        { 
            if ((i + j) % 2 == 0)
            {
                SetWindow(-0.6, 0.6, -0.6, 0.6);
            }
            else
            {
                SetWindow(-0.6, 0.6, 0.6, -0.6);
            }
            SetViewport(i * L, L + i * L, j * L, L + j * L);
            hexSwirl();
            //for (int k = 0; k <= 200000000; k++);
        }
    }

    //swap buffers for a smooth change from one
    //frame to another
    glutSwapBuffers();
    glFlush();
}

void reShape(int nNewWidth, int nNewHeight)
{
    nWidth = nNewWidth;
    nHeight = nNewHeight;
}

int main(int argc, char** argv)
{
    glutInit(argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);//设置显示模式
    glutInitWindowSize(nWidth, nHeight);
    glutInitWindowPosition(WINDOW_POS_X, WINDOW_POS_Y);
    glutCreateWindow("hexSwirl");
    glutDisplayFunc(myDisplay);
    glutReshapeFunc(reShape);
    myInit();
    glutMainLoop();//进入消息循环

    return 0;
}

#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <windows.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glut.h>
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"") //设置连接器选项

const int WINDOW_WIDTH = 640;
const int WINDOW_HEIGHT = 480;
const int WINDOW_POS_X = 300;
const int WINDOW_POS_Y = 150; 
const int NUM = 55000;
const double PI = atan(1.0) * 4;

struct GLintPoint
{
    GLint x;
    GLint y;
}; 

class Point2
{
public:
    float x, y;
    void set(float dx, float dy) {x = dx; y = dy;}
    void set(Point2 p) {x = p.x; y = p.y;}
    Point2(float xx, float yy) {x = xx, y = yy;}
    Point2() {x = y = 0;}
};
Point2 curpos, cp;

void moveTo(Point2 p)
{
    cp.set(p);
}

void lineTo(Point2 p)
{
    glBegin(GL_LINES);
    glVertex2f(cp.x, cp.y);
    glVertex2f(p.x, p.y);
    glEnd();
    glFlush();
    cp.set(p);
}

void myInit()
{
    glClearColor(1.0, 0.0, 0.0, 0.0);
    glColor3f(0.0f, 1.0f, 0.0f);
    glPointSize(4.0);//设置点的大小为4*4像素
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-WINDOW_WIDTH / 2, WINDOW_WIDTH / 2, -WINDOW_HEIGHT / 2, WINDOW_HEIGHT / 2);
}

void rosette(int N, float radius)
{
    Point2* pointlist = new Point2[N];

    GLfloat theta = (2.0 * PI) / N;
    for (int c = 0; c < N; ++c)
    {
        pointlist``` stylus.set(radius * sin(c * theta), radius * cos(theta * c));
    }

    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < N; ++j)
        {
            moveTo(pointlist[i]);
            lineTo(pointlist[j]);
        }
    }
}

void myDisplay()
{
    glClear(GL_COLOR_BUFFER_BIT);//清屏
    glViewport(10, 10, 640, 480);
    rosette(5, 200);
    glFlush();//送往设备显示
}

int main(int argc, char** argv)
{
    glutInit(argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);//设置显示模式
    glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    glutInitWindowPosition(WINDOW_POS_X, WINDOW_POS_Y);
    glutCreateWindow("花环");
    glutDisplayFunc(myDisplay);//注册重绘回调函数
    myInit();
    glutMainLoop();//进入消息循环

    return 0;
}