windows环境中：%MySQL(和PHP搭配之最佳组合)_installdir%\my.ini　//一般在MySQL(和PHP搭配之最佳组合)安装目录下有my.ini即MySQL(和PHP搭配之最佳组合)的配置文件。
linux环境中：/etc/my.cnf

在[MySQL(和PHP搭配之最佳组合)d]配置段添加如下一行：
skip-grant-tables

保存退出编辑。

2、然后重启MySQL(和PHP搭配之最佳组合)服务

windows环境中：
net stop MySQL(和PHP搭配之最佳组合)
net start MySQL(和PHP搭配之最佳组合)

linux环境中：
/etc/init.d/MySQL(和PHP搭配之最佳组合)d restart

3、设置新的ROOT密码

然后再在命令行下执行：
MySQL(和PHP搭配之最佳组合) -uroot -p MySQL(和PHP搭配之最佳组合)
直接回车无需密码即可进入数据库了。

现在我们执行如下语句把root密码更新为 7758521：
update user set password=PASSWORD("7758521") where user='root';

quit 退出MySQL(和PHP搭配之最佳组合)。

4、还原配置文件并重启服务

然后修改MySQL(和PHP搭配之最佳组合)配置文件把刚才添加的那一行删除。

再次重起MySQL(和PHP搭配之最佳组合)服务，密码修改完毕。

修改完毕。

用新密码7758521试一下吧，又能登入MySQL(和PHP搭配之最佳组合)的感觉就是不一样吧？

在如何自己编写文本控件时，有关于如何展开Tab的具体做法：

 1void TextView::PaintLine(HDC hdc,int line_no)
 2
 3{
 4
 5       int length = document->GetLineLength(line_no + start_line_no);
 6
 7       char *buffer = new char[length];
 8
 9       document->GetLineBuffer(buffer,line_no + start_line_no);
10
11       //容纳单行文本矩形区域
12
13       RECT line_rect;
14
15       GetClientRect(tv_hwnd,&line_rect);
16
17       line_rect.top = line_no*(font_height + font_extra);
18
19       line_rect.bottom = line_rect.top + font_height + font_extra;
20
21       line_rect.left -= start_column_no*5;
22
23       //展开Tab字符
24
25       int tab = 4*font_width;
26
27       int width = TabbedTextOut(hdc,line_rect.left,line_rect.top,buffer,length,1,&tab,line_rect.left);//输出文字
28
29       line_rect.left = LOWORD(width);
30
31       ExtTextOut(hdc,0,0,ETO_OPAQUE,&line_rect,0,0,0);
32
33       delete []buffer;
34
35}
36

要明白他的意思才能在以后的编写扩展功能才能得心应手。首先要明白一个函数。

TabbedTextOut

功能：

1将一个字符串写到指定位置。

2并按制表位位置数组里的值展开制表符。

函数原型：

LONG TabbedTextOut(HDC hdc, int X, int Y, LPCTSTR lpString, int nCount, int nTabPositions, LPINT lpn TabStopPositions, int nTabOrigin)

参数意义：

Hdc ：设备环境句柄。

X：   字符串开始点的x坐标（逻辑单位）。

Y：   字符串开始点的y坐标（逻辑单位）。

lpString：缓冲区指针。

nCount： 字符数。

nTabPositions：指定制表位位置数组的值的个数。

lpnTabStopPositions：数组，包含制表位位置（逻辑单位）。必须按照升序保存。

nTabOrigin：指定制表符展开的开始位置的x坐标（逻辑单位）。

返回值：字符串的尺寸，高位字表示高度，低位表示宽度。

注：

【1】       如果nTabPositions值为0，且lpnTabStopPositions值位NULL，那么制表符会按平均字符宽度的8位来扩展。

【2】       如果lpnTabStopPositions数组包含一个以上的话，则制表位被设为数组里的每一个值，共为lpnTabStopPositions个。

【3】       nTabOrigin参数允许一个应用程序为一行多次调用TabbedTextOut。如果应用程序多次调用TabbedTextOut，nTabOrigin每次都设置相同的值，则此函数在相对于nTabOrigin指定的位置处展开所有的制表符。

知识补充：

TabbedTextOut(hdc,line_rect.left,line_rect.top,buffer,length,1,&tab,line_rect.left);

第六个参数为nTabPosition = 1

第七个参数为lpnTabStopPositions = tab = 4*font_width

第八个参数位nTabOrigin = line_rect.left

因为编辑器以行位模型，当然是从一行的最左端开始。制表位数组值一个等于字体宽度的4倍。

摘自《windows编程》的解释：

TabbedTextOut的前五个参数与TextOut相同，第六个参数是跳位间隔数，第七个是以图素为单位的跳位间隔数组。

【1】  如果平均字符宽度是8个图素，而您希望每5个字符加一个跳位间隔，则这个数组将包含40、80、120，按递增顺序依此类推。

【2】       如果第六个和第七个参数是0或NULL，则跳位间隔按每八个平均字符宽度设定。

【3】       如果第六个参数是1，则第七个参数指向一个整数，表示跳位间隔重复增大的倍数（例如，如果第六个参数是1，并且第七个参数指向值为30的变量，则跳位间隔设定在30、60、90…图素处）。最后一个参数给出了从跳位间隔开始测量的逻辑x坐标，它与字符串的起始位置可能相同也可能不同。

编辑器的展开tab属于【3】，增大倍数是4个字符宽度。4倍与8倍的区别如图：

发现自己的审美观不咋的，俺觉得漂亮的人家觉得不漂亮。还是照着大家要求的画一个。

主要解决的问题是，这次行列都用宏表示，这样可以修改行列，窗口大小也动态改变。

另外长条旋转变成Z型问题也解决，主要是取模的时候绕回去了。

其中最重要的要算是解决了刷新闪烁问题，尽管HAM2008指点过，始终没做成，这次vczh说了一句话就点醒了我。根本不应该使用InvalidateRect函数，直接画，然后用缓冲DC就可以了。

VOID OnPaint()
{
    HDC hdc = GetDC(hWnd);
    HDC bitmap_dc = CreateCompatibleDC(hdc);
    HBITMAP bitmap = CreateCompatibleBitmap(hdc,1024,768);
    SelectObject(bitmap_dc,bitmap);
    
   /**//********************************************
   DrawBlock
   *********************************************/
   int x = tetris.GetX();
   int y = tetris.GetY();

   for(int i=0; i<4; ++i)
   {
       for(int j=0; j<4; ++j)
       {
           if(current_block[i][j] == 1)
           {
               DrawBlock(bitmap_dc,y+i+1,x+j+1,3,3,tetris.GetColor(),RGB(0,0,0));
           }
       }
   }

   /**//*****************************************
   *DrawContainer
   ******************************************/
   for(int i=0; i<ROWS; ++i)
   {
       for(int j=0; j<COLS; ++j)
       {
           if(Container[i][j] == 1)
           {
               DrawBlock(bitmap_dc,i+1,j+1,3,3,ColorTable[i][j],RGB(0,0,0));
           }
       }
   }

   BitBlt(hdc,0,0,1024,768,bitmap_dc,0,0,SRCCOPY);
   DeleteDC(bitmap_dc);
   DeleteObject(bitmap);
   ReleaseDC(hWnd,hdc);
}

现在看看《编程之美》的俄罗斯方块的思路，又想起vczh用脚本的写的俄罗斯方块，就又起了兴趣。便重新设计完成了，这次基本没什么bug了。只不过操作习惯上和QQ的俄罗斯方块还有些不同。

1.       在底部的时候，如果按住旋转不放，则会停留原地旋转。原因是为了检测接触底部时旋转不插入墙壁，就同接触左右墙壁一样，做了调整方块坐标处理。处理方法是根据旋转后方块的坐标加上（减去）最大列(最小列)在减去（左）右边界得到。底部也是这样计算的。当然有了这样的检测便出现了这样的小小的bug，不过我相信没人会在底部按住不放的。

2.       这次方块全部存储在一个一维数组中，通过指针的变换来改变方块种类与旋转状态，但是为了方便操作，就拷贝到了一个二维数组中。起初设计是一个四维数组，这样就方便多了，但是VS2008的编译器却不能编译通过，int[4][4]到int **p的转换不成功，朋友说是编译器问题。后来经Lend3d说，很多项目都是不用大于二维的数组的，于是干脆就用了一维数组，本来要听从他意见用结构表示一个低二位的数组元素，但是初始化和使用都不是很方便。

3.       另外关于GDI缓冲，试用了一下，但是作用貌似不大，不知道原因。关于这方面的知识援助还是要感谢HAM2008的帮助。

#ifndef TETRIS_H
#define TETRIS_H

#pragma once

extern int Container[18][10];//容纳方块的空间
extern int current_block[4][4];

/**//****************************
* 方块的主要行为
*****************************/
class Tetris
{
public:
    Tetris();
    ~Tetris();
    void GenerateBlock();
    void StepLeft();
    void StepRight();
    void StepDown();
    void Rotate();
    void CaculateScore();
    void IsOver();
public:
    bool lost;
    int score;//得分
    int GetX();
    int GetY();
private:
    inline int CaculateMinCol();
    inline int CaculateMinRow();
    inline int CaculateMaxCol();
    inline int CaculateMaxRow();

    void CaculateBlockBoundary();
    bool DetectCollision();
    void CopyToContainer();
    void CopyToBlock();

    int *block;
    int total_rotate;
    int kind;

    int offset_x;
    int offset_y;

    int min_col,max_col;
    int min_row,max_row;
};

#endif //TETRIS_H

SetClipData proc lpData:LPSTR,dwSize:dword
    LOCAL    hMem:HANDLE ;==>内存块句柄
    LOCAL    pMem:dword  ;==>内存块指针

    mov        eax,dwSize
    shr        eax,3
    inc        eax
    shl        eax,3 ;==>(dwSize/8 + 1)*8 不满8的倍数则补全
    invoke xGlobalAlloc, GHND or GMEM_DDESHARE, eax
    test    eax,eax       ;==>申请成功则继续否则跳转到@exit2
    je        @exit2
    mov        hMem,eax
    invoke GlobalLock,eax    ;hGlob ;==>锁定申请的内存块返回内存块指针
    test    eax,eax
    je        @exit1
    mov        pMem,eax
    invoke RtlMoveMemory,eax,lpData,dwSize  ;==>复制lpData的内容到申请的内存块中
    mov        eax,pMem
    add        eax,dwSize
    mov        byte ptr [eax],0 ;==>在内存块最后添0结束
    invoke GlobalUnlock,hMem ;==>解锁，使内存块指针无效
    invoke OpenClipboard,NULL
    .if eax
        invoke EmptyClipboard
        invoke SetClipboardData,CF_TEXT,hMem ;==>将数据关联到剪贴板
        invoke CloseClipboard
        xor        eax,eax        ;0 - Ok
        jmp        @exit3
    .endif
  @exit1:
    invoke  GlobalFree, hMem ;==>未锁定成功则释放该内存块
    xor     eax, eax
  @exit2:
    dec     eax          ; -1 - error
  @exit3:
    ret

SetClipData endp

看完这段代码我有一个疑问，这里是将lpData的数据拷贝到一个内存块，然后与剪贴板关联，我这里解释为关联，我就认为剪贴板不应该是一个内存区域，我猜测是一个链表之类的结构，然后链表每一个节点存储一个内存区域的指针还有其他的信息，然后根据信息来管理。

否则应该可以直接将lpData来跟剪贴板关联。另一个原因是lpData是局部的随时会被释放的。如有不正确还望指正。

自己做的控件最主要的功能就是接受你发给他的命令，也就是要给外部调用的接口。控件有自己的消息处理函数比如

LRESULT CALLBACK PETextViewWndProc(HWND hWnd,UINT Message,WPARAM wParam,LPARAM lParam)
{
    PETextView *View = (PETextView*)GetWindowLong(hWnd,0);

    switch(Message)
    {
    case WM_NCCREATE:
        if((View = new PETextView(hWnd)) == 0)
            return false;

        SetWindowLong(hWnd,0,(LONG)View);
        return true;

    case WM_NCDESTROY:
        if(View)delete View;
        return 0;

    case WM_PAINT:
        return View->OnPaint();

    case WM_SIZE:
        return View->OnSize(wParam, LOWORD(lParam), HIWORD(lParam));

    case PEM_OPENFILE:
        return View->OpenFile((TCHAR*)lParam);

    case PEM_CLEAR:
        return View->ClearFile();
    default:
        break;
    }

    return DefWindowProc(hWnd,Message,wParam,lParam);
}

这里有两类消息，一类是系统定义的以WM开头，一类是自己定义的，当然随便你自己定义啦。对应的消息看到是调用相应的函数完成的，这也就是说控件的行为就可以另外编写逻辑部分，然后提供接口给这里调用即可。

之所以说控件就是窗口是因为他有自己的窗口类，以及初始化函数，同时也有创建的函数。窗口类的定义和注册也做成提供给外部的接口，在外部必要的时候调用。而控制控件是通过发送消息来实现的，为了更加好看，可以定义一个宏，比如

#define PE_OpenFile(hWnd, Path)        SendMessage((hWnd), PEM_OPENFILE, 0, (LPARAM)(Path))

那么创建窗口和控件唯一不同的地方就是，内部的创建和销毁消息是WM_NCCREATE和WM_NCDESTROY，先不管这两个消息。我们看到WM_NCCREATE之前有个GetWindowLong，其内有个SetWindowLong。这两个是关键的，这样就设置了这个控件的属性，使其关联起来，第二个参数msdn上是没有说明设置为0是什么意思的，其实这两个函数的第二个参数设置0表示读取的意思，第一个是读取该控件的属性，然后第二个函数在增加第三个参数的属性的同时读取赋予给这个控件。

一切都OK了！那么控件创建可在外部的WM_CREATE之时调用，当然也可以在使用其功能前调用即可。

一切提供给外部的调用都Port在一个头文件中，这样使用的时候包含这个头文件就好了。

接下来解释那两个消息，这两个消息是因为我们创建了子窗口，也就是我们自己的控件。

这两个消息与WM_CREATE,WM_DESTROY之间的顺序关系是这样的，只看销毁吧。

hwnd = parent, uMsg = WM_DESTROY
hwnd = child, uMsg = WM_DESTROY
hwnd = child, uMsg = WM_NCDESTROY
hwnd = parent, uMsg = WM_NCDESTROY

WM_DESTROY是通知子窗口销毁，然后子窗口通过接受WM_NCDESTROY进行销毁，并发送给父窗口，进行销毁。

细节部分介绍的差不多，总体思路就是和创建窗口差不多，但是要搞个头文件，把一些个常量和功能的函数另外一个窗口类的初始化和创建的接口搞进去。

Scintilla文档的每个字符都紧跟关联的样式信息。一个字节的字符信息和一个字节的样式信息作为一个单位。样式信息高3位是指示器，低5位是索引号。索引号索引一个存放样式的数组。这样就可以表示32种基础样式，几乎包含所有语言的样式。三个无关指示器可以一次显示语法错误，非法命名，和缩进错误。关于样式的位可以通过SCI_SETSTYLEBITS来改变最多其中7位，剩下的位用于指示器。

字符位置信息以0开始计数，至nLen-1，中文的字符是两个字符为一个文字，这样计数就有误了（DBCS）

Scintilla的消息都是以SCI_GETxxx或者SCI_SETxxx来命名的

一．文本取回与修改

主要消息有：

SCI_GETTEXT(int length, char *text)

SCI_SETTEXT(<unused>, const char *text)

SCI_SETSAVEPOINT

SCI_GETLINE(int line, char *text)

SCI_REPLACESEL(<unused>, const char*text)

SCI_SETREADONLY(bool readOnly)

SCI_GETREADONLY

SCI_GETTEXTRANGE(<unused>, TextRange*tr)

SCI_ALLOCATE(int bytes, <unused>)

SCI_ADDTEXT(int length, const char *s)

SCI_ADDSTYLEDTEXT(int length, cell *s)

SCI_APPENDTEXT(int length, const char*s)

SCI_INSERTTEXT(int pos, const char*text)

SCI_CLEARALL

SCI_CLEARDOCUMENTSTYLE

SCI_GETCHARAT(int position)

SCI_GETSTYLEAT(int position)

SCI_GETSTYLEDTEXT(<unused>, TextRange*tr)

SCI_SETSTYLEBITS(int bits)

SCI_GETSTYLEBITS

SCI_TARGETASUTF8(<unused>, char *s)

SCI_ENCODEDFROMUTF8(const char *utf8,char *encoded)

SCI_SETLENGTHFORENCODE(int bytes)

1）SCI_GETTEXT(int length, char *text)

此函数可以取得控件中的字符串存到一个缓冲区，这样就可以保存文档了。流程是使用SCI_GETLENGTH获得字符串的长度然后根据取得的长度申请一个缓冲区，再利用该消息取得文本，然后就可以保存文本了，同时需要利用SCI_SETSAVEPOINT标记文本已保存了。

做了例子果然是可以运行的，不知道作者是如何制作这样一个控件的。我对他的内部运行机制很感兴趣，想仔细看一些具体的代码，而不是仅仅使用它。另外发现API使用的字符是宽字符，这一点很令人讨厌。

另外获取处理函数的过程用了上次写的typedef的用法，改一下看上去就清晰多了


typedef int (*EditorSendFun)(void*,int,int,int);
void* ptr;
EditorSendFun editsendmessage;

const_cast，reinterpret_cast，static_cast，dynamic_cast等等。   

1）static_cast<T*>(a)   

将地址a转换成类型T，T和a必须是指针、引用、算术类型或枚举类型。   

表达式static_cast<T*>(a), a的值转换为模板中指定的类型T。在运行时转换过程中，不进行类型检查来确保转换的安全性。   

例子：   

class B {  };   

class D : public B {  };   

void f(B* pb, D* pd)   

{    

   D* pd2 = static_cast<D*>(pb);        // 不安全, pb可能只是B的指针   

   B* pb2 = static_cast<B*>(pd);        // 安全的   
    
} 

2）dynamic_cast<T*>(a)   

完成类层次结构中的提升。T必须是一个指针、引用或无类型的指针。a必须是决定一个指针或引用的表达式。   

表达式dynamic_cast<T*>(a) 将a值转换为类型为T的对象指针。如果类型T不是a的某个基类型，该操作将返回一个空指针。   

例子：   

class A {  };   

class B {  };    

void f()   

{   

  A* pa = new A;   

  B* pb = new B;   

  void* pv = dynamic_cast<A*>(pa);   

  // pv 现在指向了一个类型为A的对象   
   

  pv = dynamic_cast<B*>(pb);   

  // pv 现在指向了一个类型为B的对象   

}  

3）const_cast<T*>(a)   

去掉类型中的常量，除了const或不稳定的变址数，T和a必须是相同的类型。   

表达式const_cast<T*>(a)被用于从一个类中去除以下这些属性：const, volatile, 和 __unaligned。   

例子：   

class A {  };   

void f()   

{   

 const A *pa = new A;//const对象   

 A *pb;//非const对象   

//pb = pa; // 这里将出错，不能将const对象指针赋值给非const对象   

 pb = const_cast<A*>(pa); // 现在OK了   

..   }  

4）reinterpret_cast<T*>(a)   

任何指针都可以转换成其它类型的指针，T必须是一个指针、引用、算术类型、指向函数的指针或指向一个类成员的指针。   

表达式reinterpret_cast<T*>(a)能够用于诸如char* 到 int*，或者One_class* 到 Unrelated_class*等类似这样的转换，因此可能是不安全的。   

例子：   

class A {  };   

class B {  };   

void f()   

{   

  A* pa = new A;   

  void* pv = reinterpret_cast<A*>(pa);   

  // pv 现在指向了一个类型为B的对象，这可能是不安全的   

     

}  

 
本文转自http://www.libing.net.cn/read.php?520

容易出错的常用用法，做了一些整理。

一．起别名的两种用法

1.       typedef (int *） pInt;

2.       typedef   pInt (int *)

比如pInt a,b;

第一种表示： int*a;int*b;

第二种表示： int*a,b;

所以第一种更像一个类型，第二种更像宏。

二．旧式代码中声明对象

typedef struct tagPoint

{

   Int x;

   Int y;

}POINT;

POINT a,b;

三．代码简化

为复杂的声明定义一个新的简单的别名

方法：在原来的声明里逐步用别名替换一部分复杂声明，如此循环，把带变量名的部分留到最后替换，得到的就是原声明的最简化版

typedef int (*PF) (const char *, const char *);

这个声明引入了 PF 类型作为函数指针的同义字，该函数有两个 const char * 类型的参数以及一个 int 类型的返回值。

如果要使用下列形式的函数声明，那么上述这个 typedef 是不可或缺的：

PF Register(PF pf);

Register() 的参数是一个 PF 类型的回调函数，返回某个函数的地址，其署名与先前注册的名字相同。如果不用 typedef，那么代码是这样的：

int (*Register (int (*pf)(const char *, const char *)))(const char *, const char *); 

1.       载入动态链接库

1hmod = LoadLibrary("SciLexer.DLL");
2if (hmod==NULL)
3{
4       MessageBox(hwndParent,
5       "The Scintilla DLL could not be loaded.",
6       "Error loading Scintilla",
7        MB_OK | MB_ICONERROR);
8}
9

2.       创建窗口（已经注册）

hwndScintilla = CreateWindowEx(0,
               "Scintilla","", WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_CLIPCHILDREN,
               10,10,500,400,hwndParent,(HMENU)GuiID, hInstance,NULL);

二．如何控制窗口类控件

方法一：给控件发送消息和接受来自控件的响应

SendMessage(hwndScintilla,sci_command,wparam,lparam);

方法二：首先通过SCI_GETDIRECTFUNCTION 和 SCI_GETDIRECTPOINTER消息获取编辑控件回调函数的指针和第一个参数，接下来就可以直接使用编辑控件的消息处理函数了。

int (*fn)(void*,int,int,int);
void * ptr;
fn = (int (__cdecl *)(void *,int,int,int))SendMessage(hwndScintilla,SCI_GETDIRECTFUNCTION,0,0);
ptr = (void *)SendMessage(hwndScintilla,SCI_GETDIRECTPOINTER,0,0);

然后使用该回调函数：

fn(ptr,sci_command,wparam,lparam);

三．如何接受响应

只要在父窗口消息处理函数中对WM_NOTIFY消息做相应处理

NMHDR *lpnmhdr;
[]
case WM_NOTIFY:
lpnmhdr = (LPNMHDR) lParam;
if(lpnmhdr->hwndFrom==hwndScintilla)
{
     switch(lpnmhdr->code)
{
     case SCN_CHARADDED:
       […]
        break;
}}
        break;


整个过程没有任何问题，做好后是这个样子的Download。
此时你会发现该控件你没有发送任何消息就已经具备了一定的功能，有redo undo操作，还有复制黏贴。