免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
› 论坛 › 程序设计 › C/C++ › printf画的俄罗斯方块(linux异步I/O,C++)
123下一页
最近访问板块 发新帖
查看: 18588 | 回复: 28
打印 上一主题 下一主题

[C++] printf画的俄罗斯方块(linux异步I/O,C++) [复制链接]

okocha-jay

论坛徽章:
0
跳转到指定楼层
1楼 [收藏(0)] [报告]
发表于 2010-02-10 15:11 |只看该作者 |倒序浏览
本帖最后由 okocha-jay 于 2011-01-14 21:37 编辑


翻看1年前的帖子，感慨呀。。。这个代码。。还是稚嫩了一点。
现在编程风格也改了很多。而且逐渐的抛弃了LINUX,转为WIN程序员。
谢谢大家的支持，补上个图把
复制下面地址，在浏览器访问：






学C++和linux有1.5年了，但是来论坛才没几天。昨天发个帖子，大家回复都很热情

，谢谢各位帮助！(昨天帖子地址是 http://bbs.chinaunix.net/thread-1664941-1-1.html )

这个方块游戏是用linux终端的光标控制、颜色设置做的
用 A S D W 控制移动、转向，空格键下坠到底；

最初是2个线程，1个用来显示画面，1个用来接收用户输入；
后来改用单线程，linux的异步aio函数解决了很多麻烦；

用了个简单的模板单例模式，继承它就可以；
对POSIX线程简单封装成java线程接口；

bug不少，大家不吝指教和建议。

///////////main.cpp
  1. #include <memory>
  2. #include "Tetris.h"
  3. #include "TtyAuto.h"

  5. int main(int ac, char *av[])
  6. {
  7.         std::auto_ptr<TtyAuto> autoAdjustTty(TtyAuto::getInstance());

  9.         Tetris game;
  10.         game.start();
  11.         game.join();

  13.         printf("\t\t\t\t\t\t\t\t\r");
  14.         printf("GAME OVER!\n");

  16.         return 0;
  17. }
复制代码
/////////   Thread.h

  2. #ifndef BERT_THREAD_H
  3. #define BERT_THREAD_H

  5. #include <pthread.h>

  7. /**
  8. * 线程封装，接口模仿JAVA
  9. */
  10. class Runnable
  11. {
  12. public:
  13.         virtual ~Runnable() { }

  15.         /**
  16.          * 线程逻辑在此实现
  17.          */
  18.         virtual void run() = 0;
  19. };

  21. class Thread: public Runnable
  22. {
  23.         /**
  24.          * 本线程ID
  25.          */
  26.         pthread_t m_tid;

  28.         /**
  29.          * 是否在运行的标志
  30.          */
  31.         bool running;

  33.         /**
  34.          * 线程函数，内部调用run
  35.          */
  36.         static void * threadFunc(void * arg);

  38. public:
  39.         Thread();
  40.         ~Thread();

  42.         /**
  43.          * 睡眠 秒
  44.          */
  45.         static unsigned int sleep( unsigned int seconds);

  47.         /**
  48.          * 睡眠毫秒
  49.          */
  50.         static unsigned int msleep( unsigned int mSeconds);

  52.         /**
  53.          * 启动线程
  54.          */
  55.         bool start() ;

  57.         /**
  58.          * 等待本线程运行完
  59.          */
  60.         void join() const;

  62.         /**
  63.          * 是否在运行
  64.          */
  65.         bool isAlive() const
  66.         {
  67.                 return running;
  68.         }

  70.         /**
  71.          * 终止线程运行
  72.          */
  73.         void stop()
  74.         {
  75.                 running = false;
  76.         }
  77. };

  79. #endif
复制代码
////////    Thread.cc

  2. #include <unistd.h>
  3. #include <cstdlib>
  4. #include <cstdio>
  5. #include "Thread.h"

  7. Thread::Thread( ) : running(false)
  8. {
  9. }

  11. Thread::~Thread()
  12. {
  13. }

  15. void * Thread::threadFunc(void * arg)
  16. {
  17.         Thread * r = (Thread *) arg;
  18.         r->running = true;
  19.         srand(time(NULL));
  20.         r->run();
  21.         ::pthread_exit(NULL);
  22.         return NULL;
  23. }

  25. unsigned int Thread::sleep( unsigned int seconds)
  26. {
  27.         return ::sleep(seconds);
  28. }

  30. unsigned int Thread::msleep( unsigned int mSeconds)
  31. {
  32.         return ::usleep(mSeconds * 1000U);
  33. }

  35. bool Thread::start()
  36. {
  37.         if ( !running )
  38.         {
  39.                 if ( ::pthread_create(&m_tid, NULL, threadFunc, this ) )
  40.                         return false;
  41.         }
  42.         return true;
  43. }

  45. void Thread::join() const
  46. {
  47.         ::pthread_join(m_tid, NULL);
  48. }
复制代码
///  俄罗斯方块头文件

  2. #ifndef BERT_TETRIS_H
  3. #define BERT_TETRIS_H

  5. #include <bitset>
  6. #include <aio.h>

  8. #include "Thread.h"

  10. /**
  11. * 一个用printf做的linux俄罗斯方块
  12. */

  14. class Tetris : public Thread
  15. {
  16. public:
  17.         Tetris();
  18.         ~Tetris();
  19. private:
  20.         enum BOARD_T
  21.         {
  22.                 TYPE_BLANK = 0, //空白
  23.                 TYPE_BLOCK,        //阻挡
  24.                 TYPE_BORDER,        //边界

  26.                 TYPE_MAX = 3,
  27.         };
  28.        
  29.         /**
  30.          * 游戏背景,尺寸
  31.          */
  32.         static const int HEIGHT = 22;
  33.         static const int WIDTH  = 14;
  34.         BOARD_T board[HEIGHT][WIDTH] ;
  35.        
  36.         /**??是否用volatile
  37.          * 当前活动方块的坐标
  38.          */
  39.         int curx, cury;
  40.        
  41.         /**
  42.          * 当前活动方块的样式及翻转形状
  43.          */
  44.         int curstyle;
  45.         int curpos;
  46.        
  47.         /**
  48.          * 当前活动方块的颜色
  49.          */
  50.         int curcolor ;

  52.         /**
  53.          * 玩家当前得分和等级
  54.          */
  55.         unsigned int score;
  56.         unsigned short level;
  57.         static const unsigned short MAXLEVEL = 9;

  59.         /**
  60.          * 一个方块的定义
  61.          */
  62.         typedef std::bitset<16> Block;
  63.        
  64.         /**
  65.          * 方块的样式种类
  66.          */
  67.         static const unsigned short STYLE_MAX = 7;
  68.        
  69.         /**
  70.          * 当前活动方块与下一个方块
  71.          */
  72.         Block activeBlock, nextBlock;

  74.         /**
  75.          * 现在是否有活动方块?
  76.          */
  77.         bool active;

  79.         /**
  80.          * 方块样式预定义
  81.          */
  82.         static const unsigned short _styles_[STYLE_MAX][4] ;
  83.         Block styles[STYLE_MAX][4];

  85.         /**
  86.          *  初始化方块样式
  87.          */
  88.         void initStyles();
  89.        
  90.         /**
  91.          *  显示分数
  92.          */
  93.         void drawScore();
  94.        
  95.         /**
  96.          *  显示等级
  97.          */
  98.         void drawLevel();

  100.         /**
  101.          *  显示下一个方块
  102.          */
  103.         void drawNext();

  105.         /**
  106.          * 异步IO,使得单线程能完成显示和响应键盘的功能
  107.          */
  108.         struct aiocb cb;
  109.         static const int SIZE = 16;
  110.         unsigned char inputBuf[SIZE];
  111.         friend void handler(int sig, siginfo_t *info, void * context);

  113.         /**
  114.          * 初始化背景数据
  115.          */
  116.         void initBackground();

  118.         /**
  119.          * 绘制游戏画面
  120.          */
  121.         void paint(int srcx = 0, int dstx = HEIGHT);

  123.         /**
  124.          * 判断方块是否与阻挡或边界冲突
  125.          */
  126.         bool isCollide();

  128.         /**
  129.          * 消行，并返回削去的行数(0-4)
  130.          */
  131.         int removeLines();

  133.         /**
  134.          * 判断line行是否为空
  135.          */
  136.         bool isEmptyLine(int line);

  138.         /**
  139.          * 根据消行，返回应得分数
  140.          */
  141.         static const unsigned short bonus[5];

  143.         /**
  144.          * 达到相应等级所需要的分数;10-levels
  145.          */
  146.         static const unsigned int levels[10];

  148.         /**
  149.          *  根据得分，计算等级
  150.          */
  151.         static unsigned short getLevel(unsigned int score);

  153.         /**
  154.          * 线程函数，游戏逻辑
  155.          */
  156.         virtual void run();
  157. };

  159. #endif
复制代码
//////////// 俄罗斯方块 实现

  2. #include <cstdio>
  3. #include <cassert>
  4. #include <cstring>
  5. #include <cstdlib>
  6. #include <signal.h>
  7. #include <termios.h>
  8. #include <sys/ioctl.h>
  9. #include <errno.h>

  11. #include "Tetris.h"

  13. // 清除屏幕
  14. #define CLEAR()  printf("\033[2J")

  16. // 上移光标
  17. #define MOVEUP(x) printf("\033[%dA", (x))
  18. // 下移光标
  19. #define MOVEDOWN(x) printf("\033[%dB", (x))
  20. // 左移光标
  21. #define MOVELEFT(y) printf("\033[%dD", (y))
  22. // 右移光标
  23. #define MOVERIGHT(y) printf("\033[%dC",(y))

  25. // 定位光标
  26. #define MOVETO(x,y) printf("\033[%d;%dH", (x), (y))
  27. // 光标复位
  28. #define RESET_CURSOR() printf("\033[H")

  30. // 隐藏光标
  31. #define        HIDE_CURSOR() printf("\033[?25l")
  32. // 显示光标
  33. #define        SHOW_CURSOR() printf("\033[?25h")

  35. // 画背景
  36. #define DRAW_BLANK()  printf("\033[1;31;40m%s\033[0m",". " )
  37. // 画阻挡
  38. #define DRAW_BLOCK() printf("\033[7m\033[1;37;40m%s\033[0m", "[]" )
  39. // 画活动方块
  40. #define DRAW_ACTIVE_BLOCK() printf("\033[7m\033[1;%d;40m%s\033[0m",curcolor, "[]" )
  41. // 画边界
  42. #define DRAW_BORDER()  printf("\033[1;33;43m%s\033[0m", "||" )
  43. // 随机获得一种颜色
  44. #define GET_COLOR() (rand()%6 + 31)

  46. const int Tetris::HEIGHT;
  47. const int Tetris::WIDTH;
  48. const int Tetris::SIZE;
  49. const unsigned short Tetris::STYLE_MAX;
  50. const unsigned short Tetris::MAXLEVEL;
  51. const unsigned short Tetris::bonus[5] = {0, 100, 300, 600, 1000};
  52. const unsigned int Tetris::levels[MAXLEVEL+1] = {0, 10000, 30000, 60000, 100000, 150000, 210000, 280000, 360000, 450000};

  54. const unsigned short Tetris::_styles_[STYLE_MAX][4] = {
  55.                 {0x000f, 0x4444, 0x000f, 0x4444},
  56.                 {0x004e, 0x0464, 0x00e4, 0x04c4},
  57.                 {0x0462, 0x006c, 0x0462, 0x006c},
  58.                 {0x0264, 0x00c6, 0x0264, 0x00c6},
  59.                 {0x0622, 0x0017, 0x0223, 0x0074},
  60.                 {0x0644, 0x00e2, 0x044c, 0x008e},
  61.                 {0x0066, 0x0066, 0x0066, 0x0066},
  62. };

  64. unsigned short Tetris::getLevel(unsigned int score )
  65. {
  66.         int low = 0, high = MAXLEVEL;
  67.         int mid;

  69.         while ( true )
  70.         {
  71.                 mid = (low + high ) / 2;

  73.                 if ( score >= levels[mid])
  74.                                 {
  75.                                         if ( mid==MAXLEVEL || score < levels[mid+1])
  76.                                                 return mid;
  77.                                         else
  78.                                                 low = mid + 1;
  79.                                 }
  80.                                 else//不可能是mid等级
  81.                                 {
  82.                                         assert(mid>0);
  83.                                         high = mid - 1;
  84.                                 }
  85.         }
  86. }

  88. Tetris::Tetris() : score(0), level(0), active(false)
  89. {
  90.         bzero(&cb, sizeof(cb));
  91.         initStyles();
  92.         initBackground();
  93.         HIDE_CURSOR();
  94. }

  96. Tetris::~Tetris()
  97. {
  98.         SHOW_CURSOR();
  99. }

  101. void Tetris::initStyles()
  102. {
  103.         for ( int i=0; i<STYLE_MAX; ++i)
  104.         {
  105.                 for ( int j=0; j<4; ++j)
  106.                 {
  107.                         styles[i][j] = _styles_[i][j];
  108.                 }
  109.         }
  110. }

  112. void Tetris::initBackground()
  113. {
  114.         for ( int i=0; i<HEIGHT; ++i)
  115.                 for( int j=0; j<WIDTH; ++j)
  116.                 {
  117.                         if ( i==0 || j==0 || i==HEIGHT-1 || j==WIDTH-1)
  118.                                 board[i][j] = TYPE_BORDER;
  119.                         else
  120.                                 board[i][j] = TYPE_BLANK;
  121.                 }
  122. }

  124. void Tetris::paint(int srcx, int dstx)
  125. {
  126.         if ( dstx > HEIGHT )
  127.                 dstx = HEIGHT-1;

  129.         for ( int i=srcx; i<dstx; ++i)
  130.         {
  131.                 for ( int j=0; j<WIDTH; ++j)
  132.                 {
  133.                         if ( board[i][j] == TYPE_BORDER )
  134.                         {
  135.                                 DRAW_BORDER();
  136.                                 continue;
  137.                         }
  138.                        
  139.                         if ( i>=curx && i<curx+4 && j>=cury && j<cury+4 )
  140.                         {
  141.                                 if ( board[i][j] == TYPE_BLANK && activeBlock[(i-curx)*4 + j-cury] == TYPE_BLANK )
  142.                                         DRAW_BLANK();
  143.                                 else
  144.                                         DRAW_ACTIVE_BLOCK();
  145.                         }
  146.                         else
  147.                         {
  148.                                 if ( board[i][j] == TYPE_BLOCK )
  149.                                         DRAW_BLOCK();
  150.                                 else
  151.                                         DRAW_BLANK();
  152.                         }
  153.                 }
  154.                 printf("\n");
  155.         }
  156. }

  158. void Tetris::drawScore()
  159. {
  160.         MOVETO(2, 2*WIDTH+2);

  162.         printf("\033[7m\033[1;33;46m");
  163.         printf("    SCORE: ");
  164.         printf("\033[1;37;40m %-8u", score);
  165.         printf("\033[0m");
  166. }

  168. void Tetris::drawLevel()
  169. {
  170.         MOVETO(6, 2*WIDTH+2);

  172.         printf("\033[7m\033[1;34;43m");
  173.         printf("    LEVEL: ");
  174.         printf("\033[1;31;42m %-8u", level+1);//不显等级0
  175.         printf("\033[0m");
  176. }

  178. void Tetris::drawNext()
  179. {
  180.         MOVETO(11, 2*WIDTH+2);
  181.         printf("\033[1;34;43m\tNEXT:\033[0m");
  182.         MOVELEFT(5);
  183.         MOVEDOWN(2);

  185.         for ( int i=0; i<16; ++i)
  186.         {
  187.                 if ( nextBlock[i] )
  188.                         DRAW_BLOCK();
  189.                 else
  190.                         //printf("  ");
  191.                         DRAW_BLANK();

  193.                 if ( (i+1)%4 == 0 )
  194.                 {
  195.                         MOVELEFT(8);
  196.                         MOVEDOWN(1);
  197.                 }
  198.         }
  199. }

  201. bool Tetris::isCollide()
  202. {
  203.         for ( int i=curx; i<curx+4; ++i)
  204.                 for ( int j=cury; j<cury+4; ++j)
  205.                         if ( board[i][j] && activeBlock[(i-curx) * 4 + j-cury])
  206.                                 return true;

  208.         return false;
  209. }

  211. bool Tetris::isEmptyLine(int line)
  212. {
  213.         for ( int j=1; j<WIDTH-1; ++j)
  214.                 if ( board[line][j] != TYPE_BLANK )
  215.                         return false;
  216.         return true;
  217. }

  219. int Tetris::removeLines()
  220. {
  221.         int nLines = 0 ;
  222.         bool full;
  223.        
  224.         for ( int i=HEIGHT-2; i>0; --i)
  225.         {
  226.                 full = true;
  227.                 for ( int j=1; j<WIDTH-1; ++j)
  228.                         if ( board[i][j] == TYPE_BLANK )
  229.                         {
  230.                                 full = false;
  231.                                 break;
  232.                         }

  234.                 if ( full )
  235.                 {
  236.                         ++nLines;
  237.                         int k, m;
  238.                         for ( k=i-1; k>0 && !isEmptyLine(k); --k)
  239.                                 for ( m=1; m<WIDTH-1; ++m)
  240.                                         board[k+1][m] = board[k][m];
  241.                         // 消行了，k行一定为空
  242.                         assert ( k>=0 && isEmptyLine(k) );
  243.                         for ( m=1; m<WIDTH-1; ++m)
  244.                                 board[k+1][m] = TYPE_BLANK;

  246.                         ++i;
  247.                 }
  248.         }

  250.         return nLines;
  251. }

  253. void handler(int sig, siginfo_t *info, void * context)
  254. {
  255.         Tetris * game = (Tetris *)info->si_value.sival_ptr;
  256.         struct aiocb *pcb = &(game->cb);

  258.         assert( !aio_error(pcb) && "aio_handler error" );

  260.         int nbytes = aio_return(pcb);
  261.         if ( nbytes == 0  )
  262.                 return;

  264.         int nread = -1;
  265.         if ( !game->active)
  266.                 goto end;

  268.         while ( ++nread < nbytes  )
  269.         {
  270.                 switch(game->inputBuf[nread])
  271.                 {
  272.                         case 'a':
  273.                         case 'A':
  274.                                 --game->cury;
  275.                                 if ( game->isCollide() )
  276.                                         ++game->cury;
  277.                                 else
  278.                                 {
  279.                                         MOVETO(game->curx+1, 0);
  280.                                         game->paint(game->curx, game->curx+4);
  281.                                 }
  282.                                 break;
  283.                         case 's':
  284.                         case 'S':
  285.                                 ++game->curx;
  286.                                 if ( game->isCollide( ) )
  287.                                         --game->curx;
  288.                                 else
  289.                                 {
  290.                                         MOVETO(game->curx, 0 );
  291.                                         game->paint(game->curx-1, game->curx+4 );
  292.                                 }
  293.                                 break;
  294.                         case 'd':
  295.                         case 'D':
  296.                                 ++game->cury;
  297.                                 if ( game->isCollide( ) )
  298.                                         --game->cury;
  299.                                 else
  300.                                 {
  301.                                         MOVETO(game->curx+1, 0);
  302.                                         game->paint(game->curx, game->curx+4);
  303.                                 }
  304.                                 break;
  305.                         case 'w':
  306.                         case 'W':
  307.                                 {
  308.                                         Tetris::Block saveblock = game->activeBlock;
  309.                                         int savedpos = game->curpos;

  311.                                         game->curpos = (game->curpos + 1) % 4;
  312.                                         game->activeBlock = game->styles[game->curstyle][game->curpos];
  313.                                         if ( game->isCollide( ) )
  314.                                         {
  315.                                                 game->curpos = savedpos;
  316.                                                 game->activeBlock = saveblock;
  317.                                         }
  318.                                         else
  319.                                         {
  320.                                                 MOVETO(game->curx+1, 0);
  321.                                                 game->paint(game->curx, game->curx+4);
  322.                                         }
  323.                                 }
  324.                                 break;
  325.                         case ' ':
  326.                                 {
  327.                                         int oldx = game->curx;
  328.                                         // 提高效率，一次移两行
  329.                                         while ( !game->isCollide() )
  330.                                                 game->curx += 2;
  331.                                        
  332.                                         if ( game->isCollide() )
  333.                                         {
  334.                                                 --game->curx;
  335.                                                 if ( game->isCollide() )
  336.                                                         --game->curx;
  337.                                         }
  338.                                        
  339.                                         if ( oldx == game->curx )
  340.                                                 break;
  341.                                                
  342.                                         if ( game->curx - oldx < 4)
  343.                                         {
  344.                                                 MOVETO(oldx+1, 0);
  345.                                                 game->paint(oldx, game->curx+4);
  346.                                         }
  347.                                         else
  348.                                         {
  349.                                                 MOVETO(oldx+1, 0);
  350.                                                 game->paint(oldx, oldx+4);
  351.                                                 MOVETO(game->curx+1, 0);
  352.                                                 game->paint(game->curx, game->curx+4);
  353.                                         }

  355.                                         goto end;
  356.                                 }
  357.                                 break;
  358.                         default:
  359.                                 break;
  360.                 }
  361.         }

  363. end:
  364.         int ret = aio_read(pcb);
  365.         assert ( ret==0 && "aio_read error!!!");

  367.         return;
  368. }

  370. void Tetris::run()
  371. {
  372.         struct sigaction st;
  373.         sigemptyset(&st.sa_mask);
  374.         st.sa_flags = SA_SIGINFO;
  375.         st.sa_handler = reinterpret_cast<void (*)(int)>(handler);
  376.         sigaction(SIGRTMAX, &st, NULL);

  378.         cb.aio_fildes = STDIN_FILENO;
  379.         cb.aio_offset = 0;
  380.         cb.aio_buf = inputBuf;
  381.         cb.aio_nbytes = 16;
  382.         cb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
  383.         cb.aio_sigevent.sigev_signo = SIGRTMAX;
  384.         cb.aio_sigevent.sigev_value.sival_ptr = (void *)this;

  386.         sleep(1);
  387.        
  388.         int ret = aio_read(&cb);
  389.         assert ( ret==0 && "aio_read error!!!");

  391.         CLEAR();
  392.         RESET_CURSOR();
  393.         paint();
  394.         drawScore();
  395.         drawLevel();

  397.         /*预先产生一个方块*/
  398.         int next = rand()%7;
  399.         nextBlock = styles[next][0];

  401.        
  402.         while ( true )
  403.         {
  404.                 if ( !active )
  405.                 {
  406.                         activeBlock = nextBlock;
  407.                         curstyle = next;
  408.                         curcolor = GET_COLOR();
  409.                         active = true;
  410.                         curpos = 0;

  412.                         next = rand()%7;
  413.                         nextBlock = styles[next][0];
  414.                         //画下一个方块
  415.                         drawNext();
  416.                         curx = 1;
  417.                         cury = WIDTH/2 - 2;
  418.                         if ( isCollide( ) )
  419.                         {
  420.                                 return; //GAME OVER
  421.                         }
  422.                         MOVETO(curx+1, 0);
  423.                         paint(curx, curx+4);
  424.                 }
  425.                 else
  426.                 {
  427.                         ++curx;
  428.                         if ( !isCollide() )
  429.                         {
  430.                                 MOVETO(curx, 0);
  431.                                 paint(curx-1, curx+4 );
  432.                         }
  433.                         else
  434.                         {
  435.                                 --curx;
  436.                                 for ( int i=curx; i<curx+4; ++i)
  437.                                         for( int j=cury; j<cury+4; ++j)
  438.                                         {
  439.                                                 if ( activeBlock[(i-curx)*4 + j-cury] )
  440.                                                         board[i][j] = TYPE_BLOCK;
  441.                                         }
  442.                                 active = false;
  443.                                 activeBlock = 0;
  444.                                 //判断是否得分
  445.                                 int n = removeLines();
  446.                                 if ( n != 0 )
  447.                                 {
  448.                                         score += bonus[n];
  449.                                         drawScore();

  451.                                         int newlevel = getLevel(score);
  452.                                         if ( newlevel > this->level)
  453.                                         {
  454.                                                 this->level = newlevel;
  455.                                                 drawLevel();
  456.                                         }
  457.                                         //RESET_CURSOR(); //暂时全部重画，以后优化
  458.                                         //paint();
  459.                                         MOVETO(2,0);
  460.                                         paint(1, curx+4);
  461.                                 }
  462.                                 else
  463.                                 {
  464.                                         MOVETO(curx+1, 0);
  465.                                         paint(curx, curx+4 );
  466.                                 }
  467.                         }
  468.                 }
  469.                 msleep(700 - level * 60);
  470.         }
  471.         return ;
  472. }
复制代码
///////////////   模板单例模式
  1. #ifndef BERT_SINGLETON_H
  2. #define BERT_SINGLETON_H

  4. /**
  5. * 模板单例模式
  6. */
  7. template <typename T>
  8. class Singleton
  9. {
  10. protected:
  11.         Singleton() {}
  12.         ~Singleton() {}
  13.        
  14.         static T * instance;
  15.        
  16. public:
  17.         static T * getInstance()
  18.         {
  19.                 if ( instance == NULL )
  20.                         instance = new T();
  21.                 return instance;
  22.         }

  24.         static void delInstance()
  25.         {
  26.                 if ( instance )
  27.                 {
  28.                         delete instance;
  29.                         instance = NULL;
  30.                 }
  31.         }
  32. };

  34. template <typename T>
  35. T * Singleton<T>::instance = NULL;

  37. #endif
复制代码
/////////   自动设置终端属性

  2. #ifndef BERT_TTYAUTO_H
  3. #define BERT_TTYAUTO_H

  5. #include <unistd.h>
  6. #include <termios.h>
  7. #include <sys/ioctl.h>
  8. #include "Singleton.h"

  10. /**
  11. * 前向声明
  12. */
  13. namespace std
  14. {

  16. template <typename T>
  17. class auto_ptr;

  19. }

  21. class TtyAuto : public Singleton<TtyAuto>
  22. {
  23.         friend class Singleton<TtyAuto>;
  24.         friend class std::auto_ptr<TtyAuto>;

  26.         struct termios state;
  27. protected:
  28.         /**
  29.          *  构造函数,自动设置非缓冲，非回显模式
  30.          */
  31.         TtyAuto()
  32.         {
  33.                 tcgetattr(STDIN_FILENO, &state);
  34.                 state.c_lflag &= ~ICANON;
  35.                 state.c_lflag &= ~ECHO;
  36.                 tcsetattr(STDIN_FILENO, TCSANOW, &state);
  37.         }
  38.         /**
  39.          *  析构函数,自动恢复缓冲，回显模式
  40.          */
  41.         ~TtyAuto()
  42.         {
  43.                 state.c_lflag |= ICANON;
  44.                 state.c_lflag |= ECHO;
  45.                 tcsetattr(STDIN_FILENO, TCSANOW, &state);
  46.         }
  47. };

  49. #endif

复制代码
yylogo

论坛徽章:
0
2楼 [报告]
发表于 2010-02-10 15:33 |只看该作者
帮忙顶一个吧,, 虽然我没看懂(我学C的)...
不过我挺佩服你的哈,, 才学1.5年就能写出这种程序,,,,
我学了两年多了.. (天哪,, 我都干吗去了)
  我要fast了..
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
daybreakcx

论坛徽章:
0
3楼 [报告]
发表于 2010-02-10 15:36 |只看该作者
先支持一下再说{:3_193:}
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
okocha-jay

论坛徽章:
0
4楼 [报告]
发表于 2010-02-10 15:48 |只看该作者
本帖最后由 okocha-jay 于 2010-02-11 11:44 编辑

回复 2# yylogo

惭愧，我基本是个初学者，动手能力不行。

半路起家，以前是数学系的，纯数学，杯具。。

在学C++前有两年的C基础；
有本书对我影响很大，机械工业的unix环境高级编程英文版第1版1992，很小一本书。看了不下三遍，非常有收获；
使我决定了在linux下学习；
希望能和坛友们一起学习进步。
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
yylogo

论坛徽章:
0
5楼 [报告]
发表于 2010-02-10 20:11 |只看该作者
回复 4# okocha-jay


    Unix 环境高级编程看了三遍,, 额.. (俺彻底输了``)
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
bluewaterray

论坛徽章:
0
6楼 [报告]
发表于 2010-02-10 21:51 |只看该作者
unix环境高级编程  很小一本书？ 不会是山寨版吧
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
songvar

论坛徽章:
0
7楼 [报告]
发表于 2010-02-11 07:25 |只看该作者
牛人哪，我崇拜你～～
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
消失在地平线

论坛徽章:
0
8楼 [报告]
发表于 2010-02-11 09:15 |只看该作者

这书蛮厚的啊，我都当字典用{:3_184:}
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
bandaotidejia

论坛徽章:
0
9楼 [报告]
发表于 2010-02-11 11:32 |只看该作者
这本小书，都翻烂了。
给点建议，看看linux内核，代码其实不多，看看其实也是一种消遣。
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
okocha-jay

论坛徽章:
0
10楼 [报告]
发表于 2010-02-11 11:34 |只看该作者
回复 9# bandaotidejia


    谢谢你的指导。
能给些建议吗。
很久没看过内核。以前看过robert love那本书，偏理论框架而非代码实现。
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
123下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号：11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们：huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP