saiksy

记录生活中的点点滴滴

C++博客 首页 新随笔 联系 聚合 管理
  13 Posts :: 0 Stories :: 1 Comments :: 0 Trackbacks

2011年8月1日 #

 

"delete from tb_Cards" // 清空

"ALTER TABLE tb_Cards ALTER COLUMN idx COUNTER (1, 1)" // 自动编号设为1

 

posted @ 2011-08-01 22:08 saiksy 阅读(158) | 评论 (0)编辑 收藏

2011年6月13日 #

 

在CDialog::PreTranslateMessage() 的重载函数中将ESC和回车按键的消息处理掉.
  CResultCollectorDlg::PreTranslateMessage(MSG
* pMsg)
  
{

  
if(pMsg->message == WM_KEYDOWN) {

  
switch(pMsg->wParam) {

  
case VK_RETURN: //回车

        
return TRUE;

  
case VK_ESCAPE: //ESC

        
return TRUE;

  }


  }


  
return CDialog::PreTranslateMessage(pMsg);

  }

 

posted @ 2011-06-13 01:23 saiksy 阅读(287) | 评论 (0)编辑 收藏

2011年5月31日 #

标准组合键
关闭应用程序        Alt + F4              关闭 IDE。
关闭文档窗口        Ctrl + F4             关闭当前活动的文档窗口。
移动到菜单栏        Alt                   激活主 IDE 菜单栏。
移动到下一工具栏    Ctrl + Tab            移动到下一个可见的工具栏。仅在主菜单栏处于活动状态时可用。
移动到前一个工具栏  Ctrl + Shift + Tab    移动到前一个可见的工具栏。仅在主菜单栏处于活动状态时可用。
 
文本操作快捷键
编辑.完成单词       Alt + 向右键- 或 -Ctrl + 空格键    显示基于当前语言的“完整单词”。
 
窗口管理快捷键
视图.全屏                Shift + Alt+ Enter        切换“全屏”模式的打开和关闭。
视图.类视图              Ctrl + Shift + C          显示“类视图”窗口。
视图.资源视图            Ctrl + Shift + E          显示“资源视图”窗口。
视图.解决方案资源管理器  Ctrl + Alt + L  显示解决方案资源管理器,它列出当前解决方案中的项目和文件。
 
项目快捷键
生成.编译            Ctrl + F7 
生成.生成解决方案    F7
文件.新建文件        Ctrl + N
文件.新建项目        Ctrl + Shift + N
文件.打开文件        Ctrl + O
文件.打开项目        Ctrl + Shift + O

调试快捷键
调试.断点          F9         设置或取消断点
调试.启用断点      Ctrl + F9  将断点从禁用切换到启用
调试.删除所有断点  Ctrl + Shift + F9   清除项目中的所有断点。

文本选择快捷键
编辑.向左扩展一个字符  Shift + 向左键  将光标左移一个字符以扩展所选内容。
编辑.向右扩展一个字符  Shift + 向右键  将光标右移一个字符以扩展所选内容。
编辑.文档结尾扩展      Ctrl + Shift + End  选择从插入点到文档最后一行的文本。
编辑.文档开始扩展      Ctrl + Shift + Home  选择从插入点到文档首行的文本。
编辑.向下扩展一行      Shift + 向下键    从插入点位置开始,将选定文本向下扩展一行。
编辑.扩展到行尾        Shift + End   选择从插入点到当前行行尾的文本。
编辑.扩展到行首        Shift + Home   选择从插入点到行首的文本。
编辑.向上扩展一行      Shift + 向上键  从插入点位置开始向上逐行选择文本。
编辑.向下扩展一页      Shift + Page Down  将选定内容向下扩展一页。
编辑.向上扩展一页      Shift + Page Up


对象浏览器快捷键
编辑.转到声明  Ctrl + F12  显示代码中选定符号的定义。
编辑.转到定义  F12  显示代码中选定符号的声明。

类关系图快捷键
类关系图.折叠   数字键区中的 -(减号) 折叠“类详细信息”窗口中展开的节点,或折叠关系图中选定的形状隔离舱。
类关系图.展开   数字键区中的 +(加号) 展开“类详细信息”窗口中折叠的节点,或展开关系图中选定的形状隔离舱。

posted @ 2011-05-31 17:43 saiksy 阅读(1066) | 评论 (0)编辑 收藏

// Tokenizes a string into a vector
std::vector<std::string> TokenizeString(const std::string& str, const std::string& delim)
{
    
// http://www.gamedev.net/community/forums/topic.asp?topic_id=381544#TokenizeString
    using namespace std;
    vector
<string> tokens;
    size_t p0 
= 0, p1 = string::npos;
    
while(p0 != string::npos)
    
{
        p1 
= str.find_first_of(delim, p0);
        
if(p1 != p0)
        
{
            
string token = str.substr(p0, p1 - p0);
            tokens.push_back(token);
        }

        p0 
= str.find_first_not_of(delim, p1);
    }

    
return tokens;
}
posted @ 2011-05-31 14:30 saiksy 阅读(94) | 评论 (0)编辑 收藏

2011年5月19日 #

既然是从零开始,那么就搞的傻瓜一点,就算是手把手教了. 哈哈.

一下内容在vs2005实现

新建一个空的win32控制台项目.

1.首先我们来配置头文件和库文件:

头文件:

D:\Lua\lua-5.1.4\src

D:\Lua\luabind
-0.8.1

D:\Lua\boost_1_41_0

库文件:无.见代码.

 

下面就是cpp内容了:注释都是个人理解,如果您觉得不对

#include <luabind/luabind.hpp>
#pragma comment(lib,
"lualib.lib"//可能你会问,lualib.lib是哪里来的? 这是我自己编译luabind得到

//的,  如果你不知道怎么编译,参考下我的另一篇文章<从零开始使用luabind>
#include <iostream>
using namespace std;
using namespace luabind;


class testlua//写一个测试类,包括一些简单的方法.
{
public:
 testlua(std::
string s):m_str(s){};
 
void myprint()
 
{
  cout 
<< m_str << endl;
 }

 
void setstr(std::string s){ m_str = s;};
private:
 std::
string m_str;
}
;


int main()
{
 lua_State 
*= luaL_newstate();//新建一个lua_State,或者叫做创建lua状态
 luabind::open(L);//为改lua状态打开所有lua库

//把写好的类绑定到lua,以下内容为读书所得,我看的是missdeer同学翻译的luabindmanual一书.
//相信好学的你,如果不明白这是怎么用的,一定会找来这书读一读的,当然我也很乐意和您分享(Q:625425901)

 module(L)

[  
   class_
<testlua>("testlua")
   .def(constructor
<const std::string>())
   .def(
"myprint",&testlua::myprint)//开放这两个函数给lua使用
   .def("setstr"&testlua::setstr)
  ];

 
 luaL_dofile(L,
"test.lua");//执行lua文件,稍后你会看到test.lua文件的内容
 lua_close(L);//关闭lua状态
 return 0;
}


 

以下是test.lua内容:


local a 
= testlua("hello lua!");--看不懂?如果我说它在c里是这样的: testlua obj = testlua("hello lua!"),看懂了么?恩,构建testlua类的对象.

a:myprint();
//调用方法

a:setstr(
"yes lua!");

a:myprint();

 

--接下来我们在lua里尝试如下代码:

a:hisprint();

--你也许会问,这个函数不存在啊.确实不存在,但是程序并没有报错,所以或许我们需要其他的代码来处理这种错误的调用,后话了,慢慢来.

 

好了,执行一下C代码,你应该会看到想要的结果了.相信不少同学看到这里已经开始计划写一个类,用来随心所欲的开放你的C方法给lua使用了.先到这里.

欢迎批评指正.

 

posted @ 2011-05-19 01:08 saiksy 阅读(254) | 评论 (1)编辑 收藏

2011年5月18日 #

那么好吧,我们来试试luabind.以下内容参考了不少网上的教程,由于被多方转载,已经不知道作者是谁了,在这里对他们表示万分的感谢.

使用vs2005编译luabind

红色部分是我自己编译的时候遇到的一些问题,或者应该注意的地方

  1. 下载lua (我使用的版本 lua-5.1.4)
    从官方网站http://www.lua.org/download.html可得到源码包.
  2. 编译lua
    使用VS.NET环境的使用VS提供的"Visual Studio命令提示",进入解开的源码包根目录下,按readme文提示,运行etc\luavs.bat,一般即可编译成功.
  3. 对于使用lua的开发者来说,可以直接到http://luabinaries.luaforge.net/download.html下载编译后版本.
  4. 下载boost (我用的boost_1_41_0)
    从官方网站http://www.boost.org/users/download/下载源码包.
  5. 编译bjam 
    从VS命令提示进入<boost_root>\tools\jam\src\,运行build.bat. 根据需要可以使用各种参数,比如希望使用vc8(VS 2005),则运行 build.bat vc8.
    生成的目标文件在<boost_root>\tools\jam\src\bin.ntx86\bjam.exe.
  6. 编译boost
    将bjam.exe拷贝到<boost_root>目录下,在VS命令提示进入<boost_root>,运行bjam. 其他参数请自行查询.
      编译时间比较长,生成的目标文件在<boost_root>\bin.v2\libs.(或者在<boost_root> 新建一个bat,写入如下内容: bjam --toolset=msvc-8.0 --stagedir=./lib_x86 --builddir=./ address-model=32 link=static runtime-link=static threading=multi stage debug release
    bjam --toolset=msvc-8.0 --stagedir=./lib_x64 --builddir=./ address-model=64 link=static runtime-link=static threading=multi stage debug release ,参数自己按需要修改.这样你就可以直接用vs命令提示运行这个bat文件了.  )
  7. 下载luabind
    http://sourceforge.net/projects/luabind/下载源码包. (我用的luabind-0.8.1.开始的时候用的0.9rc1,编不过去)
  8. 编译luabind
    使用VS新建win32项目,新建选项为静态库Static Link Library,不使用预编译头Precompiled header. 将<luabind_root>\src下所有cpp文件加入工程. 将<boost_root>,<lua_root>\src,<luabind_root>加入附加包含路径.
    编译luabind.lib.

另外,我修改了boost_1_41_0\tools\build\v2\user-config.jam文件中的 # using msvc : 8.0;

改后: # using msvc : 8.0 : : <compileflags>/wd4819 <compileflags>/D_CRT_SECURE_NO_DEPRECATE <compileflags>/D_SCL_SECURE_NO_DEPRECATE <compileflags>/D_SECURE_SCL=0 ;

不知道这会不会对编译造成影响.

posted @ 2011-05-18 23:35 saiksy 阅读(381) | 评论 (0)编辑 收藏

每个系统都有线程,而线程的最重要的作用就是并行处理,提高软件的并发率。针对界面来说,还能提高界面的响应力。

 线程分为界面线程和工作者线程,界面实际就是一个线程画出来的东西,这个线程维护一个“消息队列”,“消息队列”也是界面线程和工作者线程的最大区别,这个词应该进到你的脑子里,根深蒂固的!

如果在界面线程的某个地方停住,这说明它处理不了窗口消息了,所以有时候我们就会看到整个界面无响应了。这种问题后面会提供一个叫 WaitForObjectEx 的函数来解决,我们后面再谈。

线程首先就是它的创建,创建是用下面这个函数:CreateThread; 具体的参数我不说了,自己查MSDN。其中的 Thread1 是线程函数。线程函数是一个全局函数,如下:

DWORD WINAPI Thread1(LPVOID lpParam)
{
  while(1)
 {
  OutputDebugString("11111");

  Sleep(10);
 }
 return 0;
}

// 下面这一句是创建线程
CreateThread(NULL, 0, Thread1, 0, 0, NULL);

当然我们不能让一个线程自生自灭,那样有可能在你退出程序的时候出现一些莫名其妙的问题,或者丢失一些数据,或者给你弹一个崩溃的对话框等等。。。

所以我们就要对这个线程进行管理,首先就是让它退出。

我们给它的while加上一个 BOOL 变量 g_bExitThread的判断,这样的话,线程函数就变成下面这样:

DWORD WINAPI Thread1(LPVOID lpParam)
{
  while(!g_bExitThread)
 {
  OutputDebugString("11111");

  Sleep(10);
 }
 return 0;
}

然后在需要它退出的时候把g_bExitThread设为TRUE,表示,喂,兄弟,你该退出了。

当然我们还要知道它是否成功退出了,因为线程句柄是一个内核对象,所以我们就要用到Windows的WaitForSingleObject来等待了。创建的时候和等待它退出的代码就要改变了,多了一个 HANDLE g_hTrd的变量:

// 创建
g_bExitThread = FALSE;
g_hTrd = CreateThread(NULL, 0, Thread1, 0, 0, NULL);

// 等待线程结束
g_bExitThread = TRUE;

 if(g_hTrd != NULL)
 {
  DWORD dwRet = WaitForSingleObject(g_hTrd, 5000);
  if(dwRet == WAIT_OBJECT_0)
  {
   AfxMessageBox("Thread exit success!");
  }
  else
  {
   DWORD dwRet = 0;
   GetExitCodeThread(g_hTrd, &dwRet);
   TerminateThread(g_hTrd, dwRet);
   AfxMessageBox("Thread exit, but not all ok!");
  }
  CloseHandle(g_hTrd);
  g_hTrd = NULL;
 }

上面说了在界面线程里等待别的线程结束,也就是使用 WaitForSingleObject 的时候会阻塞整个窗口消息的处理,所以我们如果在界面线程里要等待别的内核对象时,我们要采用这种“等一下,处理一下界面消息”的方法。我已经写好了一个 WaitForObjectEx 的函数,如下:

// 此函数只能用于界面线程
static DWORD WaitForObjectEx( HANDLE hHandle, DWORD dwMilliseconds )
{
 BOOL bRet;
 MSG msg;
 INT iWaitRet;
 int nTimeOut = 0;
 while( (bRet = ::GetMessage( &msg, NULL, 0, 0 )) != 0)
 {
  if(nTimeOut++ * 20 >= dwMilliseconds)
   break;

  iWaitRet = WaitForSingleObject(hHandle, 20);
  if(iWaitRet != WAIT_TIMEOUT)
  {
   break;
  }
  if (bRet == -1)
  {
   break;
  }
  else
  {
   ::TranslateMessage(&msg);
   ::DispatchMessage(&msg);
  }
 }

 return iWaitRet;
}

很多时候,我们不想把线程作为一个全局函数来使用,所以这个时候我们把线程作为一个类的静态成员对象来写。当然也不能少了刚才的两个变量:退出标志和线程句柄。(设这个类是CTestThreadDlg)

// H 文件
BOOL m_bExitThread;
 HANDLE m_hTrd;
 static DWORD WINAPI Thread1(LPVOID lpParam);

// CPP文件,创建的时候把 this 指针传进去,因为类静态成员函数不能访问类的非静态成员,没有this指针
//(C++的知识点)
 m_bExitThread = FALSE;
 m_hTrd = CreateThread(NULL, 0, Thread1, this, 0, NULL);

线程函数变成了:

 DWORD WINAPI CTestThreadDlg::Thread1(LPVOID lpParam)
 {
  CTestThreadDlg *pDlg = (CTestThreadDlg*)lpParam;
  while(!pDlg->m_bExitThread)
  {
   OutputDebugString("11111");
 
   Sleep(10);
  }
  return 0;
 }

 

当有几个线程一起跑的时候,我们就要注意线程的同步问题了,线程的同步一般来说,是在多个线程共用了资源的时候。比如两个线程都用到了同一个VECTOR,都对VECTOR进行插入操作,不幸的是,VECTOR不是线程安全的,这个时候程序就会崩溃,所以我们就要对VECTOR这个资源做同步,同步的意思是“我访问的时候,你等待”。程序大致如下:

DWORD WINAPI CTestThreadDlg::Thread1(LPVOID lpParam)
 {
  CTestThreadDlg *pDlg = (CTestThreadDlg*)lpParam;
  while(!pDlg->m_bExitThread)
  {
   OutputDebugString("11111");
 
   pDlg->m_csForVec.Lock();
   pDlg->m_vecTest.push_back("111");
   pDlg->m_csForVec.Unlock();
 
   Sleep(10);
  }
  return 0;
 }

DWORD WINAPI CTestThreadDlg::Thread2(LPVOID lpParam)
{
 CTestThreadDlg *pDlg = (CTestThreadDlg*)lpParam;
 while(!pDlg->m_bExitThread2)
 {
  OutputDebugString("222");

  pDlg->m_csForVec.Lock();
  pDlg->m_vecTest.push_back("222");
  pDlg->m_csForVec.Unlock();

  Sleep(10);
 }
 return 0;
}

m_csForVec 是一个CCriticalSection变量,这个同步对象和其他的同步变量(事件、信号量、互斥区等)有一些不一样,例如只能在同一个进程的线程间访问、在操作系统的用户态访问,其他的必须进入核心态。所以这样导致了这种关键区的核心对象的速度要比其他的快100倍左右。。。

上面已经说了线程的创建、管理(退出线程、等待线程)、同步等,那我们发现了什么共性呢?作为一个程序员,我们要很敏感的发现这些代码上的共性,这是我们设计代码的主要前提。

首先我们发现上面的线程都有两个变量:
BOOL m_bExitThread;  // 让线程退出的标志
 HANDLE m_hTrd;  // 线程句柄

另外我们WaitForSingleObject 的时候不能无限等待,所以要多一个 DWORD m_dwWaitTimeOut;

由于我想把线程启动和结束封装起来,所以我设计了这几个接口:

 BOOL Start(LPVOID lpParam);  //  启动线程,线程所需要的参数从这里传进
 BOOL End(); // 结束线程
 virtual void Run(); // 重写Run函数

所以整个的线程封装成以下的类:

// MyThread.h

#ifndef MY_THREAD_H
#define MY_THREAD_H

class CMyThread
{
public:
 CMyThread();
 virtual ~CMyThread();

 BOOL Start(LPVOID lpParam);
 BOOL End();
 virtual void Run();

protected:
 static DWORD WINAPI Thread(LPVOID lpParam);
 void RunOnceEnd();

 DWORD m_dwWaitTimeOut;
 BOOL m_bExitThread;
 HANDLE m_hTrd;
 LPVOID m_lpParam;
};

#endif

// MyThread.Cpp

#include "stdafx.h"
#include "MyThread.h"
/////////////////////////////////////////////////////////////////////////////
// CMyThread
CMyThread::CMyThread()
{
 m_bExitThread = FALSE;
 m_hTrd = NULL;
 m_dwWaitTimeOut = 5000;
}

CMyThread::~CMyThread()
{

}

BOOL CMyThread::Start(LPVOID lpParam)
{
 m_lpParam = lpParam;
 m_bExitThread = FALSE;
 m_hTrd = CreateThread(NULL, 0, Thread, this, 0, NULL);

 return TRUE;
}

BOOL CMyThread::End()
{
 m_bExitThread = TRUE;

 if(m_hTrd != NULL)
 {
  DWORD dwRet = WaitForSingleObject(m_hTrd, m_dwWaitTimeOut);
  if(dwRet == WAIT_OBJECT_0)
  {
   AfxMessageBox("Thread exit success!");
  }
  else
  {
   DWORD dwRet = 0;
   GetExitCodeThread(m_hTrd, &dwRet);
   TerminateThread(m_hTrd, dwRet);
   AfxMessageBox("Thread fucking exit!");
  }

  CloseHandle(m_hTrd);
  m_hTrd = NULL;
 }
 
 return TRUE;
}

DWORD WINAPI CMyThread::Thread(LPVOID lpParam)
{
 CMyThread *pTrd = (CMyThread *)lpParam;
 
 while(!pTrd->m_bExitThread)
 {
  pTrd->Run();
 }

 return 0;
}

void CMyThread::RunOnceEnd()
{
 m_bExitThread = TRUE;
 CloseHandle(m_hTrd);
 m_hTrd = NULL;
}

void CMyThread::Run()
{
}

我们需要写我们自己的线程的时候就重载一下这个Run函数

// 派生出一个类
class CMyThread1 : public CMyThread
{
public:
 virtual void Run();
};

// 改写Run函数
void CMyThread1::Run()
{
 CTestThreadDlg *pDlg = (CTestThreadDlg *)m_lpParam;

 OutputDebugString("222");
 
 pDlg->m_csForVec.Lock();
 pDlg->m_vecTest.push_back("222");
 pDlg->m_csForVec.Unlock();
 
 Sleep(10);

 // 如果此线程只想运行一次,加上下面这句
 RunOnceEnd();
}


然后我们之前的两个线程的使用就变成了下面的形式:

CMyThread1 g_t1, g_t2, g_t3;
void CTestThreadDlg::OnButton3()
{
 g_t1.Start(this);
 g_t2.Start(this);
 g_t3.Start(this);
}

void CTestThreadDlg::OnButton4()
{
 g_t1.End();
 g_t2.End();
 g_t3.End(); 
}

只需要以下几步:
1、派生自己的线程类
2、重载Run函数
3、调用Start启动线程
4、调用End结束线程

当然这种封装方式是我自己喜欢的,封装的目的是方便使用,隐藏细节,诸位看官也可以根据自己的喜好,封装线程的使用方法,如果能在此公开一下你的成果,让我和大家都学习一下你的设计手法,那就真是very good and 3q了!

 


本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/dylgsy/archive/2008/03/13/2176160.aspx

posted @ 2011-05-18 22:43 saiksy 阅读(220) | 评论 (0)编辑 收藏

2011年5月8日 #

     摘要: RtlAdjustPrivilege(SE_DEBUG_PRIVILEGE,1,0,NULL);这个函数封装在NtDll.dll中(在所有DLL加载之前加载),被微软严格保密,就是说你在MSDN上查不到关于他的任何信息。.常量 SE_BACKUP_PRIVILEGE, "17", 公开.常量 SE_RESTORE_PRIVILEGE, "18",&...  阅读全文
posted @ 2011-05-08 17:22 saiksy 阅读(405) | 评论 (0)编辑 收藏

2011年5月5日 #

//-------------------------------------------
//当想在Win32 Application时想在控制台输出一些调试
//信息,可以先创建一个控制台,再重定向输入,输出
//-------------------------------------------
AllocConsole();   
    HANDLE   handle   
=   GetStdHandle(STD_OUTPUT_HANDLE);
    
int   hCrt   =   _open_osfhandle((long)handle,_O_TEXT);
    FILE   
*   hf   =   _fdopen(   hCrt, "w");
    
*stdout   =   *hf;
    setvbuf( stdout, NULL, _IONBF, 
0 ); 
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY 
| FOREGROUND_GREEN);   //改变控制台文本颜色
posted @ 2011-05-05 17:46 saiksy 阅读(236) | 评论 (0)编辑 收藏

2010年9月13日 #

在系统菜单中增加的命令其ID值必须小于0xF000;否则它们将会与Windows系
统菜单命令所使用的ID值相冲突。还要记住,当您为这些新菜单项在窗口消息处理程序中处理
WM_SYSCOMMAND  消  息  时  ,  您  必  须  把  其  它  的  WM_SYSCOMMAND  消  息  发  送  给
DefWindowProc。如果您不这样做,那么实际上是禁用了系统菜单上的所有正常选项。
posted @ 2010-09-13 23:09 saiksy 阅读(54) | 评论 (0)编辑 收藏

仅列出标题  下一页