国产精品一区二区三区成人,久久国产精品久久久久久电车,国产欧美激情

SDI Minimize and Maxinum flash windw

Wed, 13 Apr 2011 02:02:00 GMT

Why the flash occurs

In order to understand why the application does not minimize properly, we need to look into the MFC code that constructs and displays the main window. By placing a breakpoint in the ProcesShellCommand function, we see that, by default, the AppWnd OnFileNew handler is called. OnFileNew calls the CDocument* CDocument* CSingleDocTemplate::OpenDocumentFile(LPCTSTR lpszPathName,BOOL bMakeVisible) OpenDocument, which creates a new document instance, creates a new frame for the document, and finally displays the window by calling InitialUpdateFrame(pFrame, pDocument, bMakeVisible);, and displays the view and the mainframe window. The reason why the application does not display correctly when a different SW parameter is chosen instead of SW_SHOW, is because InitialUpdateFrame CFrameWnd::ActivateFrame() calls ShowWindow during the initialization of the window in the function. This implies that the call to ShowWindow in InitInstance() is redundant and not needed.

The solution

There are two solutions that can be used to solve the flashing problem. The first solution is to make a subclass of the SingleDocumentTemplate and call our derived version of OpenDocument with bMakeVisible = false for the minimized case. This, however, does not solve the case of using SW_MAXMIMIZE. Another solution, which is far more simpler and can be used for any ShowWIndow mode, is to set the application ShowWindow property prior to initializing the window, as shown below:

Collapse | Copy Code

        CSingleDocTemplate * pDocTemplate;
pDocTemplate = new CSingleDocTemplate (
IDR_MAINFRAME,
RUNTIME_CLASS(CMyMFCProgramDoc),
RUNTIME_CLASS(CMainFrame),       // main SDI frame window
RUNTIME_CLASS(CMyMFCProgramView));
AddDocTemplate(pDocTemplate);
// Parse command line for standard shell commands, DDE, file open
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
// Add the following line:
// Set the initial window display to whatever mode you like
this->m_nCmdShow = SW_MAXIMIZE;
// Dispatch commands specified on the command line
if (!ProcessShellCommand(cmdInfo))
return FALSE;
// The following line should be deleted since it is not needed 
// for a SDI application that used MFC The one and only window has
// been initialized, so show and update it.
//m_pMainWnd->ShowWindow(SW_SHOW);
m_pMainWnd->UpdateWindow();
return TRUE;

One may ask if the ShowWindow() line in the InitInstance has no purpose, and why Microsoft put that line there in the first place. The answer is, if one decides to construct an SDI application using the MFC application wizard and checks the option not to use MFC, this line is required to show the window. However, Microsoft should have deleted this line if MFC is used. However, since the vast majority of applications initially display ShowWindow with the SW_SHOW parameter, calling ShowWindow twice (the first time in ActivateFrame, as described above) will not influence the display of the application.

漫步者�?…�?�K?/a> 2011-04-13 10:02 发表评论

AfxMessageBoxFormatted and MessageBoxFormatted

Wed, 13 Apr 2011 01:50:00 GMT

void AfxMessageBoxFormatted(LPCTSTR pFormatString, ...)
{
    va_list vl;
    va_start(vl, pFormatString);

    CString strFormat;
    strFormat.FormatV(pFormatString, vl); // This Line is important!

    // Display message box.
    AfxMessageBox(strFormat);
}

void MessageBoxFormatted(HWND hWnd, LPCTSTR pCaption, LPCTSTR pFormatString, ...)
{
    va_list vl;
    va_start(vl, pFormatString);

    TCHAR strFormat[1024]; // Must ensure size!

    // Generic version of vsprintf, works for both MBCS and Unicode builds
    _vstprintf(strFormat, pFormatString, vl);

    // Or use following for more secure code
    // _vstprintf_s(strFormat, sizeof(strFormat), pFormatString, vl)

    ::MessageBox(hWnd, strFormat, pCaption,MB_ICONINFORMATION);
}

漫步者�?…�?�K?/a> 2011-04-13 09:50 发表评论

函数指针

Wed, 13 Apr 2011 01:48:00 GMT

在程序运行中�Q�函��C��码是�E�序的算法指令部分，它们和数�l�一样也占用存储�I�间�Q�都有相应的地址。可以��用指针变量指向数�l�的首地址�Q�也可以使用指针变量指向函数代码的首地址�Q�指向函��C��码首地址的指针变量称为函数指针�?/span>

1�Q�函数指针定�?/span>

函数�c�d�� Q?/font>*指针变量名）(形参列表)�Q?/span>

“函数�c�d��”说明函数的返回类型，�׃��“()”的优先��高于“*”,所以指针变量名外的括号必不可少�Q�后面的“形参列表”表示指针变量指向的函数所带的参数列表�?/span>

例如�Q?/span>

int (*f)(int x);

double (*ptr)(double x);

在定义函数指针时��h��意：

函数指针和它指向的函数的参数个数和类型都应该�?/font>�?/span>致的�Q?/span>

函数指针的类型和函数的返回值类型也必须是一致的�?/span>

2�Q�函数指针的赋�?/span>

函数名和数组名一样代表了函数代码的首地址�Q�因此在赋值时�Q�直接将函数指针指向函数名就行了�?/span>

例如�Q?/span>

int func(int x); /* 声明一个函�?/font> */

int (*f) (int x); /* 声明一个函数指�?/font> */

f=func; /* ��?/font>func函数的首地址赋给指针f */

赋值时函数func不带括号�Q�也不带参数�Q�由�?/font>func代表函数的首地址�Q�因此经�q�赋��g��后，指针f��指向函�?/font>func(x)的代码的首地址�?/span>

3�Q�通过函数指针调用函数

函数指针是通过函数名及有关参数�q�行调用的�?/span>

与其他指针变量相�c�M��Q�如果指针变�?/font>pi是指向某整型变量i的指针，�?/font>*p�{�于它所指的变量i�Q�如�?/font>pf是指向某��点型变�?/font>f的指针，�?/font>*pf��q��价于它所指的变量f。同样地�Q?/font>*f是指向函�?/font>func(x)的指针，�?/font>*f��׃��表它所指向的函�?/font>func。所以在执行�?/font>f=func;之后�Q?/font>(*f)�?/font>func代表同一函数�?/span>

�׃��函数指针指向存储��Z��的某个函敎ͼ�因此可以通过函数指针调用相应的函数。现在我们就讨论如何用函数指针调用函敎ͼ�它应执行下面三步�Q?/span>

首先�Q�要说明函数指针变量�?/span>

例如�Q?/font>int (*f)(int x);

其次�Q�要对函数指针变量赋倹{�?/span>

例如�Q?/font> f=func; (func(x)必须先要有定�?/font>)

最后，要用 (*指针变量)(参数�?/font>);调用函数�?/span>

例如�Q?/font> (*f)(x);(x必须先赋�?/font>)

漫步者�?…�?�K?/a> 2011-04-13 09:48 发表评论

What are TCHAR, WCHAR, LPSTR, LPWSTR, LPCTSTR etc?

Wed, 13 Apr 2011 01:47:00 GMT

VC 字符串相兛_�� _T�?/span>TEXT,_TEXT�?/span>L 的作�?/span>

一�?/span> 在字�W�串前加一�?/span>L作用:

�?/span> L"我的字符�?/span>" 表示��?/span>ANSI字符串�{换成unicode的字�W�串�Q�就是每个字�W�占用两个字节�?/span>

strlen("asd") = 3;

strlen(L"asd") = 6;

二�?/span> _T宏可以把一个引号引��h��的字�W�串�Q�根据你的环境设�|�，使得�~�译器会�Ҏ��~�译目标环境选择合适的�Q?/span>Unicode�q�是ANSI�Q�字�W�处理方�?/span>

如果你定义了UNICODE�Q�那�?/span>_T宏会把字�W�串前面加一�?/span>L。这�?/span> _T("ABCD") 相当�?/span> L"ABCD" �Q�这是宽字符丌Ӏ?/span>

如果没有定义�Q�那�?/span>_T宏不会在字符串前面加那个L�Q?/span>_T("ABCD") ��q��价于 "ABCD"

三�?/span>TEXT,_TEXT �?/span>_T 一��L��

如下面三语句�Q?/span>

TCHAR szStr1[] = TEXT("str1");

char szStr2[] = "str2";

WCHAR szStr3[] = L("str3");

那么�W�一句话在定义了UNICODE时会解释为第三句话，没有定义时就�{�于�W�二句话�?/span>

但二句话无论是否定义�?/span>UNICODE都是生成一�?/span>ANSI字符�Ԍ��而第三句话��L��生成UNICODE字符丌Ӏ?/span>

��Z��E�序的可�U�L��性，��都用�W�一�U�表�C�方法�?/span>

但在某些情况下，某个字符必须�?/span>ANSI�?/span>UNICODE�Q�那��q��后两�U�方法�?/span>

Many C++ Windows programmers get confused over what bizarre identifiers like TCHAR, LPCTSTR are. Here, in brief, I would try to clear out the fog.

In general, a character can be 1 byte or 2 bytes. Lets say 1-byte character is ANSI, using which English characters are represented. And lets say 2-byte character is Unicode, which can represent ALL languages in the world.

VC++ support char and wchar_t as native datatypes for ANSI and Unicode characters respectively.

What if you want your C/C++ program to be Character-mode independent?
That means, instead of replacing:

Collapse | Copy Code

char cResponse; // 'Y' or 'N'
char sUsername[64];
// str* functions

with

Collapse | Copy Code

wchar_t cResponse; // 'Y' or 'N'
wchar_t sUsername[64];
// wcs* functions

You can simply code it:

Collapse | Copy Code

#include<TCHAR.H> // Implicit or explicit include
TCHAR cResponse; // 'Y' or 'N'
TCHAR sUsername[64];
// _tcs* functions

Thus, when your project is being compiled as Unicode, the TCHAR would translate to wchar_t. If it is being compiled as ANSI/MBCS, it would translated to char. Likewise, instead of using strcpy, strlen, strcat (including the secure versions suffixed with _s); or wcscpy, wcslen, wcscat (including secure), you can simply use _tcscpy, _tcslen, _tcscat functions.

When you need to express hard-coded string, you can use:

Collapse | Copy Code

"ANSI String"; // ANSI
L"Unicode String"; // Unicode

_T("Either string, depending on compilation"); // ANSI or Unicode
// or use TEXT macro, if you need more readability.

The non-prefixed string is ANSI string, the L prefixed string is Unicode, and string specified in _T or TEXT would be either, depending on compilation.

String classes, like MFC/ATL's CString implement two version using macro. There are two classes named CStringA for ANSI, CStringW for Unicode. When you use CString (which is a macro/typedef), it translates to either of two classes.

Okay. The TCHAR type-definition was for a single character. You can definitely declare an array of TCHAR.
What if you want to express a character-pointer, or a const-character-pointer - Which one of the following?

Collapse | Copy Code

// ANSI characters
foo_ansi(char*);
foo_ansi(const char*);
/*const*/ char* pString;

// Unicode/wide-string
foo_uni(WCHAR*); // or wchar_t*
foo_uni(const WCHAR*);
/*const*/ WCHAR* pString;

// Independent
foo_char(TCHAR*);
foo_char(const TCHAR*);
/*const*/ TCHAR* pString;

After reading about TCHAR stuff, you'd definitely select the last one as your choice. But here is better alternative. Before that, note that TCHAR.H header file declares only TCHAR datatype and for the following stuff, you need to include Windows.h (defined in WinNT.h).

NOTE: If your project implicitly or explicitly includes Windows.h, you need not to include TCHAR.H

char* replacement: LPSTR
const char* replacement: LPCSTR
WCHAR* replacement: LPWSTR
const WCHAR* replacement: LPCWSTR (C before W, since const is before WCHAR)
TCHAR* replacement: LPTSTR
const TCHAR* replacement: LPCTSTR

Now, I hope, you understand the following signatures :

Collapse | Copy Code

BOOL SetCurrentDirectory( LPCTSTR lpPathName );
DWORD GetCurrentDirectory(DWORD nBufferLength,LPTSTR lpBuffer);

Continuing. You must have seen some functions/methods asking you to pass number of characters, or returning the number of characters. Well, like GetCurrentDirectory, you need to pass number of characters, and not number of bytes. For example::

Collapse | Copy Code

TCHAR sCurrentDir[255];

// Pass 255 and not 255*2
GetCurrentDirectory(sCurrentDir, 255);

On the other side, if you need to allocate number or characters, you must allocate proper number of bytes. In C++, you can simply use new:

Collapse | Copy Code

LPTSTR pBuffer; // TCHAR*

pBuffer = new TCHAR[128]; // Allocates 128 or 256 BYTES, depending on compilation.

But if you use memory allocation functions like malloc, LocalAlloc, GlobalAlloc etc; you must specify the number of bytes!

Collapse | Copy Code

pBuffer = (TCHAR*) malloc (128 * sizeof(TCHAR) );

Typecasting the return value is required, as you know. The expression in malloc's argument ensures that it allocates desired number of bytes - and makes up room for desired number of characters.

漫步者�?…�?�K?/a> 2011-04-13 09:47 发表评论

�Q��{�Q�C、C++ 旉��

Mon, 27 Apr 2009 03:11:00 GMT

C++ 旉��

本文从介�l�基��概念入手�Q�探讨了在C/C++中对日期和时间操作所用到的数据结构和函数�Q��ƈ对计时、时间的获取、时间的计算和显�C�格式等斚w��q�行了阐�q�。本文还通过大量的实例向你展�C�Z��time.h头文件中声明的各�U�函数和数据�l�构的详�l��用方法�?nbsp;

关键字：UTC�Q�世界标准时��_��Q�Calendar Time�Q�日历时��_��Q�epoch�Q�时间点�Q�，clock tick�Q�时钟计时单元）

1�Q�概�?nbsp;
在C/C++中，对字�W�串的操作有很多值得注意的问题，同样�Q�C/C++�Ҏ��间的操作也有许多值得大家注意的地斏V��最�q�，在技术群中有很多�|�友也多�ơ问�?�q�C++语言中对旉��的操作、获取和昄��{�等的问题。下面，在这��文章中�Q�笔者将主要介绍在C/C++中时间和日期的��用方�?

通过学习许多C/C++库，你可以有很多操作、��用时间的�Ҏ��。但在这之前你需要了解一�?#8220;旉��”�?#8220;日期”的概念，主要有以下几个：

Coordinated Universal Time�Q�UTC�Q�：协调世界�Ӟ��又称��Z��界标准时��_��也就是大家所熟知的格林威��L��准时��_��Greenwich Mean Time�Q�GMT�Q�。比如，中国内地的时间与UTC的时差�ؓ+8�Q�也��是UTC+8。美国是UTC-5�?nbsp;

Calendar Time�Q�日历时��_��是用“从一个标准时间点到此时的旉��l�过的秒�?#8221;来表�C�的旉��。这个标准时间点对不同的�~�译器来说会有所不同�Q�但对一个编译系�l�来 ��_��q�个标准旉��Ҏ��不变的，该编译系�l�中的时间对应的日历旉��都通过该标准时间点来衡量，所以可以说日历旉��?#8220;相对旉��”�Q�但是无��Z��在哪一个时区，在同一时刻对同一个标准时间点来说�Q�日历时间都是一��L��?nbsp;

epoch�Q?nbsp; 旉��炏V��时间点在标准C/C++中是一个整敎ͼ�它用此时的时间和标准旉��点相差的�U�数�Q�即日历旉��Q�来表示�?nbsp;

clock tick�Q�时钟计时单元（而不把它叫做旉��滴答�ơ数�Q�，一个时钟计时单元的旉��长短是由CPU控制的。一个clock tick不是CPU的一个时钟周期，而是C/C++的一个基本计时单位�?nbsp;

我们可以使用ANSI标准库中的time.h头文件。这个头文�g中定义的旉��和日期所使用的方法，无论是在�l�构定义�Q�还是命名，都具有明昄��C语言风格。下面，我将说明在C/C++中怎样使用日期的时间功能�?nbsp;

2�Q?计时

C/C++中的计时函数是clock()�Q�而与其相关的数据�c�d��是clock_t。在MSDN中，查得对clock函数定义如下�Q?nbsp;

clock_t clock( void );

�q?个函数返回从“开启这个程序进�E?#8221;�?#8220;�E�序中调用clock()函数”时之间的CPU旉��计时单元�Q�clock tick�Q�数�Q�在MSDN中称之�ؓ挂钟旉��Q�wal-clock�Q�。其中clock_t是用来保存时间的数据�c�d��Q�在time.h文�g中，我们可以扑ֈ��?它的定义�Q?nbsp;

#ifndef _CLOCK_T_DEFINED
typedef long clock_t;
#define _CLOCK_T_DEFINED
#endif

很明显，clock_t是一个长整�Ş数。在time.h文�g中，�q�定义了一个常量CLOCKS_PER_SEC�Q�它用来表示一�U�钟会有多少个时钟计时单元，其定义如下：

#define CLOCKS_PER_SEC ((clock_t)1000)

可以看到每过千分之一�U�（1毫秒�Q�，调用clock�Q�）函数�q�回的值就�?。下面�D个例子，你可以��用公式clock()/CLOCKS_PER_SEC来计��一个进�E�自�w�的�q�行旉��Q?nbsp;

void elapsed_time()
{
printf("Elapsed time:%u secs.\n",clock()/CLOCKS_PER_SEC);
}

当然�Q�你也可以用clock函数来计��你的机器运行一个��@环或者处理其它事件到底花了多��时��_��

#include “stdio.h”
#include “stdlib.h”
#include “time.h”

int main( void )
{
long i = 10000000L;
clock_t start, finish;
double duration;
/* ��量一个事件持�l�的旉��*/
printf( "Time to do %ld empty loops is ", i );
start = clock();
while( i-- ) ;
finish = clock();
duration = (double)(finish - start) / CLOCKS_PER_SEC;
printf( "%f seconds\n", duration );
system("pause");
}

在笔者的机器上，�q�行�l�果如下�Q?nbsp;

Time to do 10000000 empty loops is 0.03000 seconds

上面我们看到旉��计时单元的长度�ؓ1毫秒�Q�那么计时的�_�ֺ�也�ؓ1毫秒�Q�那么我们可不可以通过改变CLOCKS_PER_SEC的定义，通过把它定义的大一些，从而��计时�_�ֺ�更高呢？通过��试�Q�你会发现这��h��不行的。在标准C/C++中，最��的计时单位是一毫秒�?nbsp;

3�Q�与日期和时间相关的数据�l�构

在标准C/C++中，我们可通过tm�l�构来获得日期和旉��Q�tm�l�构在time.h中的定义如下�Q?nbsp;

#ifndef _TM_DEFINED
struct tm {
int tm_sec; /* �U?– 取值区间�ؓ[0,59] */
int tm_min; /* �?- 取值区间�ؓ[0,59] */
int tm_hour; /* �?- 取值区间�ؓ[0,23] */
int tm_mday; /* 一个月中的日期 - 取值区间�ؓ[1,31] */
int tm_mon; /* 月䆾�Q�从一月开始，0代表一月） - 取值区间�ؓ[0,11] */
int tm_year; /* �q�䆾�Q�其值等于实际年份减�?900 */
int tm_wday; /* 星期 – 取值区间�ؓ[0,6]�Q�其�?代表星期天，1代表星期一�Q�以此类�?*/
int tm_yday; /* 从每�q�的1�?日开始的天数 – 取值区间�ؓ[0,365]�Q�其�?代表1�?日，1代表1�?日，以此�c�L�� */
int tm_isdst; /* 夏��o时标识符�Q�实行夏令时的时候，tm_isdst为正。不实行夏��o时的�q�候，tm_isdst�?�Q�不了解情况�Ӟ��tm_isdst()��?/
};
#define _TM_DEFINED
#endif

ANSI C标准�U�C��用tm�l�构的这�U�时间表�C�Zؓ分解旉��(broken-down time)�?nbsp;

而日历时��_��Calendar Time�Q�是通过time_t数据�c�d��来表�C�的�Q�用time_t表示的时��_��日历旉��Q�是从一个时间点�Q�例如：1970�q?�?�?�?�?�U�）到此时的�U�数。在time.h中，我们也可以看到time_t是一个长整型敎ͼ�

#ifndef _TIME_T_DEFINED
typedef long time_t; /* 旉��?*/
#define _TIME_T_DEFINED /* 避免重复定义 time_t */
#endif

�?家可能会产生疑问�Q�既然time_t实际上是长整型，到未来的某一天，从一个时间点�Q�一般是1970�q?�?�?�?�?�U�）到那时的�U�数�Q�即日历旉��Q?��出了长整�Ş所能表�C�的数的范围怎么办？对time_t数据�c�d��的值来��_��它所表示的时间不能晚�?038�q?�?8�?9�?4�?7�U�。�ؓ了能够表�C?更久�q�的旉��Q�一些编译器厂商引入�?4位甚��x��长的整�Ş数来保存日历旉��。比如微软在Visual C++中采用了__time64_t数据�c�d��来保存日历时��_��q��过_time64()函数来获得日历时��_��而不是通过使用32位字的time()�?敎ͼ��Q�这样就可以通过该数据类型保�?001�q?�?�?�?�?�U�（不包括该旉��点）之前的时间�?nbsp;

在time.h头文件中�Q�我们还可以看到一些函敎ͼ�它们都是以time_t为参数类型或�q�回值类型的函数�Q?nbsp;

double difftime(time_t time1, time_t time0);
time_t mktime(struct tm * timeptr);
time_t time(time_t * timer);
char * asctime(const struct tm * timeptr);
char * ctime(const time_t *timer);

此外�Q�time.h�q�提供了两种不同的函数将日历旉��Q�一个用time_t表示的整敎ͼ�转换为我们��^时看到的把年月日时分�U�分开昄��的时间格式tm�Q?nbsp;

struct tm * gmtime(const time_t *timer);
struct tm * localtime(const time_t * timer);

�?�q�查阅MSDN�Q�我们可以知道Microsoft C/C++ 7.0中时间点的��|��time_t对象的��|��是从1899�q?2�?1�?�?�?�U�到该时间点所�l�过的秒敎ͼ�而其它各�U�版本的Microsoft C/C++和所有不同版本的Visual C++都是计算的从1970�q?�?�?�?�?�U�到该时间点所�l�过的秒数�?nbsp;

4�Q�与日期和时间相关的函数及应�?nbsp;
在本节，我将向大家展�C�怎样利用time.h中声明的函数�Ҏ��间进行操作。这些操作包括取当前旉��、计��时间间隔、以不同的�Ş式显�C�时间等内容�?nbsp;

4.1 获得日历旉��

我们可以通过time()函数来获得日历时��_��Calendar Time�Q�，其原型�ؓ�Q?br>time_t time(time_t * timer);

�?果你已经声明了参数timer�Q�你可以从参数timer�q�回现在的日历时��_��同时也可以通过�q�回��D��回现在的日历旉��Q�即从一个时间点�Q�例如：1970�q?1�?�?�?�?�U�）到现在此时的�U�数。如果参��Cؓ�I�（NUL�Q�，函数��只通过�q�回��D��回现在的日历旉��Q�比如下面这个例子用来显�C�当前的日历旉��Q?

#include "time.h"
#include "stdio.h"
int main(void)
{
struct tm *ptr;
time_t lt;
lt =time(NUL);
printf("The Calendar Time now is %d\n",lt);
return 0;
}

�q�行的结果与当时的时间有养I��我当时运行的�l�果是：

The Calendar Time now is 1122707619

其中1122707619��是我运行程序时的日历时间。即�?970�q?�?�?�?�?�U�到此时的秒数�?nbsp;

4.2 获得日期和时�?nbsp;

�q�里说的日期和时间就是我们��^时所说的�q�、月、日、时、分、秒�{�信息。从�W?节我们已�l�知道这些信息都保存在一个名为tm的结构体中，那么如何��一个日历时间保存�ؓ一个tm�l�构的对象呢�Q?nbsp;

其中可以使用的函数是gmtime()和localtime()�Q�这两个函数的原型�ؓ�Q?nbsp;

struct tm * gmtime(const time_t *timer);
struct tm * localtime(const time_t * timer);

�?中gmtime()函数是将日历旉��转化��Z��界标准时��_��x��林尼��L��_��Q��ƈ�q�回一个tm�l�构体来保存�q�个旉��Q�而localtime()函数是将日历旉��转化为本地时间。比如现在用gmtime()函数获得的世界标准时间是2005�q?�?0�?�?8�?0�U�，那么我用localtime()函数�?中国地区获得的本地时间会比世界标准时间晚8个小�Ӟ��?005�q?�?0�?5�?8�?0�U�。下面是个例子：

#include "time.h"
#include "stdio.h"
int main(void)
{
struct tm *local;
time_t t;
t=time(NUL);
local=localtime(&t);
printf("Local hour is: %d\n",local->tm_hour);
local=gmtime(&t);
printf("UTC hour is: %d\n",local->tm_hour);
return 0;
}

�q�行�l�果是：

Local hour is: 15
UTC hour is: 7

4.3 固定的时间格�?nbsp;

我们可以通过asctime()函数和ctime()函数��时间以固定的格式显�C�出来，两者的�q�回值都是char*型的字符丌Ӏ�返回的旉��格式为：

星期�?月䆾日期 �?�?�U?�q�\n\0
例如�Q�Wed Jan 02 02:03:55 1980\n\0

其中\n是一个换行符�Q�\0是一个空字符�Q�表�C�字�W�串�l�束。下面是两个函数的原型：

char * asctime(const struct tm * timeptr);
char * ctime(const time_t *timer);

�?中asctime()函数是通过tm�l�构来生成具有固定格式的保存旉��信息的字�W�串�Q�而ctime()是通过日历旉��来生成时间字�W�串。这��L��话， asctime�Q�）函数只是把tm�l�构对象中的各个域填到时间字�W�串的相应位�|�就行了�Q�而ctime�Q�）函数需要先参照本地的时间设�|�，把日历时间�{化�ؓ 本地旉��Q�然后再生成格式化后的字�W�串。在下面�Q�如果t是一个非�I�的time_t变量的话�Q�那么：

printf(ctime(&t));

�{��h于：

struct tm *ptr;
ptr=localtime(&t);
printf(asctime(ptr));

那么�Q�下面这个程序的两条printf语句输出的结果就是不同的了（除非你将本地时区设�ؓ世界标准旉��所在的时区�Q�：

#include "time.h"
#include "stdio.h"
int main(void)
{
struct tm *ptr;
time_t lt;
lt =time(NUL);
ptr=gmtime(<);
printf(asctime(ptr));
printf(ctime(<));
return 0;
}

�q�行�l�果�Q?nbsp;

Sat Jul 30 08:43:03 2005
Sat Jul 30 16:43:03 2005

4.4 自定义时间格�?nbsp;

我们可以使用strftime�Q�）函数��时间格式化为我们想要的格式。它的原型如下：

size_t strftime(
char *strDest,
size_t maxsize,
const char *format,
const struct tm *timeptr
);
      我们可以�Ҏ��format指向字符串中格式命��o把timeptr中保存的旉��信息攑֜�strDest指向的字�W�串中，最多向strDest中存放maxsize个字�W�。该函数�q�回向strDest指向的字�W�串中放�|�的字符数�?nbsp;

�?数strftime()的操作有些类��g��sprintf()�Q�识别以癑ֈ��?%)开始的格式命��o集合�Q�格式化输出�l�果攑֜�一个字�W�串中。格式化命��o说明�?strDest中各�U�日期和旉��信息的确切表�C�方法。格式串中的其他字符原样放进串中。格式命令列在下面，它们是区分大��写的�?nbsp;

%a 星期几的��?nbsp;
%A 星期几的全称
%b 月分的简�?nbsp;
%B 月䆾的全�U?nbsp;
%c 标准的日期的旉��?nbsp;
%C �q�䆾的后两位数字
%d 十进制表�C�的每月的第几天
%D �?�?�q?nbsp;
%e 在两字符域中�Q�十�q�制表示的每月的�W�几�?nbsp;
%F �q?�?�?nbsp;
%g �q�䆾的后两位数字�Q��用基于周的年
%G �q�分�Q��用基于周的年
%h ��写的月䆾�?nbsp;
%H 24��时制的��时
%I 12��时制的��时
%j 十进制表�C�的每年的第几天
%m 十进制表�C�的月䆾
%M 十时制表�C�的分钟�?nbsp;
%n 新行�W?nbsp;
%p 本地的AM或PM的等��h��C?nbsp;
%r 12��时的时�?nbsp;
%R 昄��时和分钟：hh:mm
%S 十进制的�U�数
%t 水��^制表�W?nbsp;
%T 昄��时分�U�：hh:mm:ss
%u 每周的第几天�Q�星期一为第一�?�Q��g��0�?�Q�星期一�?�Q?nbsp;
%U �W�年的第几周�Q�把星期日做为第一天（��g��0�?3�Q?nbsp;
%V 每年的第几周�Q��用基于周的年
%w 十进制表�C�的星期几（��g��0�?�Q�星期天�?�Q?nbsp;
%W 每年的第几周�Q�把星期一做�ؓ�W�一天（��g��0�?3�Q?nbsp;
%x 标准的日期串
%X 标准的时间串
%y 不带世纪的十�q�制�q�䆾�Q��g��0�?9�Q?nbsp;
%Y 带世�U�部分的十进制年�?nbsp;
%z�Q?Z 时区名称�Q�如果不能得到时区名�U�则�q�回�I�字�W��?nbsp;
%% 癑ֈ��?nbsp;

如果��x��C�现在是几点了，�q�以12��时制显�C�，��p��下面�q�段�E�序�Q?nbsp;

#include “time.h”
#include “stdio.h”
int main(void)
{
struct tm *ptr;
time_t lt;
char str[80];
lt=time(NUL);
ptr=localtime(<);
strftime(str,100,"It is now %I %p",ptr);
printf(str);
return 0;
}

其运行结果�ؓ�Q?nbsp;
It is now 4PM

而下面的�E�序则显�C�当前的完整日期�Q?nbsp;

#include
#include

void main( void )
{
struct tm *newtime;
char tmpbuf[128];
time_t lt1;
time( <1 );
newtime=localtime(<1);
strftime( tmpbuf, 128, "Today is %A, day %d of %B in the year %Y.\n", newtime);
printf(tmpbuf);
}

�q�行�l�果�Q?nbsp;

Today is Saturday, day 30 of July in the year 2005.

4.5 计算持箋旉��的长�?nbsp;

有时候在实际应用中要计算一个事件持�l�的旉��长度�Q�比如计��打字速度。在�W?节计旉��分中�Q�我已经用clock函数举了一个例子。Clock()函数可以�_��到毫�U��。同�Ӟ��我们也可以��用difftime()函数�Q�但它只能精��到�U�。该函数的定义如下：

double difftime(time_t time1, time_t time0);

虽然该函数返回的以秒计算的时间间隔是double�c�d��的，但这�q�不说明该时间具有同double一��L��_��度，�q�是由它的参数觉得的�Q�time_t是以�U��ؓ单位计算的）。比如下面一�D늨�序：

#include "time.h"
#include "stdio.h"
#include "stdlib.h"
int main(void)
{
time_t start,end;
start = time(NUL);
system("pause");
end = time(NUL);
printf("The pause used %f seconds.\n",difftime(end,start));//<-
system("pause");
return 0;
}

�q�行�l�果为：
��h��L��键��l? . .
The pause used 2.000000 seconds.
��h��L��键��l? . .

可以惛_��Q�暂停的旉��q�不那么巧是整整2�U�钟。其实，你将上面�E�序的带�?#8220;//<-”注释的一行用下面的一行代码替换：

printf("The pause used %f seconds.\n",end-start);

其运行结果是一��L��?nbsp;

4.6 分解旉��转化为日历时�?nbsp;

�q�里说的分解旉��是以年、月、日、时、分、秒�{�分量保存的旉��l�构�Q�在C/C++中是tm�l�构。我们可以��用mktime�Q�）函数��用tm�l�构表示的时间�{化�ؓ日历旉��。其函数原型如下�Q?nbsp;

time_t mktime(struct tm * timeptr);

其返回值就是�{化后的日历时间。这��h��们就可以先制定一个分解时��_��然后对这个时间进行操作了�Q�下面的例子可以计算�?997�q?�?日是星期几：

#include "time.h"
#include "stdio.h"
#include "stdlib.h"
int main(void)
{
struct tm t;
time_t t_of_day;
t.tm_year=1997-1900;
t.tm_mon=6;
t.tm_mday=1;
t.tm_hour=0;
t.tm_min=0;
t.tm_sec=1;
t.tm_isdst=0;
t_of_day=mktime(&t);
printf(ctime(&t_of_day));
return 0;
}
�q�行�l�果�Q?nbsp;
Tue Jul 01 00:00:01 1997
     现在注意了，有了mktime()函数�Q�是不是我们可以操作现在之前的�Q何时间呢�Q�你可以通过�q�种办法��出1945�q?�?5��h��星期几吗�Q�答案是否定的。因��个时间在1970�q?�?日之前，所以在大多数编译器中，�q�样的程序虽然可以编译通过�Q�但�q�行时会异常�l�止�?
5�Q��ȝ��
本文介绍了标准C/C++中的有关日期和时间的概念�Q��ƈ通过各种实例讲述了这些函数和数据�l�构的��用方法。笔者认为，和时间相关的一些概忉|��相当重要的，理解�q�些概念是理解各�U�时间格式的转换的基��Q�更是应用这些函数和数据�l�构的基��?/p>

漫步者�?…�?�K?/a> 2009-04-27 11:11 发表评论

Debug函数的实玎ͼ�转）

Sun, 19 Apr 2009 13:04:00 GMT

#define DBGPRT(fmt,args...) \
   do{ \
    FILE* fp= fopen("/home/debug.log","a+"); \
    if( fp != NULL ) \
    { \
     fprintf(fp," \n %s(%d)-%s: \n",__FILE__,__LINE__,__FUNCTION__); \
     fprintf(fp,fmt,##args); \
     fclose(fp); \
     } \
   }while(0);

漫步者�?…�?�K?/a> 2009-04-19 21:04 发表评论

Sun, 19 Apr 2009 12:49:00 GMT

记得刚开始工作时�Q�一位高手告诉我�Q�说�Q�longjmp和setjmp玩得不熟�Q�就不要自称为C语言高手。当时我半信半疑�Q��ؓ了让自己向高手方向迈�q�，�q�是�׃��一�Ҏ��间去学习longjmp和setjmp的用法。后来明白那不单是蟩来蟩去那��L��单，而是一�U�高�U�的异常处理机制�Q�在某些情况下确实很有用�?/p>

��Z��昄��自己的技巧，也在自己的程序中用过几次。渐渐发现这��L��技巧带来的好处是有代�h的，破坏了程序的�l�构化设计，�E�序变得很难读，��其�Ҏ��手来说。终于明白这�U�技巧不�q�是一�U�调��x��Q�在��数情况使用几次�Q�可以简化对问题的处理。如果把调味拿来当饭吃，一定会本末倒置�Q�写出的�E�序会呈现营��M��良之状�?/p>

事实上，longjmp和setjmp玩得熟不熟与是不是C语言高手�Q�不是因果关�p�R��但是，如果可以套用那位高手的话�Q�我倒想说如果函数指针玩得不熟，��׃��要自�U�CؓC语言高手。�ؓ什么这么说呢，函数指针有那么复杂吗�Q�当然不是，��M��一个稍有编�E�常识的人，不管他懂不懂C语言�Q�在10分钟内，我想他一定可以明白C语言中的函数指针是怎么回事�?/p>

原因在于�Q�难的不是函数指针的概念和语法本�w�，而是在什么时候，什么地方该使用它。函数指针不仅是语法上的问题�Q�更重要的是它是一个设计范畴。真正的高手当然不单应该懂得语法层面上的技巧，更应该懂得设计上的方法。不懂设计，能算高手吗？怀疑我在夸大其辞吗�Q�那我们先看看函数指针与哪些设计�Ҏ��有关�Q?/p>

与分层设计有兟�?/strong>分层设计早就不是什么新的概念，分层的好处是众所周知的，比较明显好处��是��化复杂度、隔��d��化。采用分层设计，每层都只需兛_��自己的东西，�q�减��了�pȝ��的复杂度�Q�层与层之间的交互仅限于一个很�H�的接口�Q�只要接口不变，某一层的变化不会影响其它层，�q�隔��M��变化�?/p>

分层的一般原则是�Q�上层可以直接调用下层的函数�Q�下层则不能直接调用上层的函数。这句话说来��单，在现实中�Q�下层常常要反过来调用上层的函数。比如你在拷贝文件时�Q�在界面层调用一个拷贝文件函数。界面层是上层，拯��文�g函数是下层，上层调用下层�Q�理所当然。但是如果你惛_��拯��文�g时还要更新进度条�Q�问题就来了。一斚w��Q�只有拷贝文件函数才知道拯��的进度，但它不能��L��新界面的�q�度条。另外一斚w��Q�界面知道如何去更新�q�度条，但它又不知道拯��的进度。怎么办？常见的做法，��是界面讄��一个回调函数给拯��文�g函数�Q�拷贝文件函数在适当的时候调用这个回调函数来通知界面更新状态�?/p>

与抽象有兟�?/strong>抽象是面向对象中最重要的概念之一�Q�也是面向对象威力强大之处。面向对象只是一�U�思想�Q�大安��知道�Q�用C语言一样可以实现面向对象的�~�程。这可不是�ؓ了赶旉��Q�而是一�U�实用的�Ҏ��。如果你�Ҏ��表示怀疑，可以�ȝ��看GTK+、linux kernel�{�开源代码�?/p>

接口是最高��的抽象。在linux kernel里面�Q�接口的概念无处不在�Q�像虚拟文�g�pȝ��(VFS)�Q�它定义一个文件系�l�的接口�Q�只要按照这�U�接口的规范�Q�你可以自己开发一个文件系�l�挂上去。设备驱动程序更是如此，不同的设备驱动程序有自己一套不同的接口规范。在自己开发设备开发驱动程序时�Q�只要遵循相应的接口规范��p��了。接口在C语言中如何表�C�？很简单，��是一�l�函数指针�?/p>

与接口与实现分开有关。针�Ҏ��口编�E�，而不是针对实现编�E�，此�ؓ《设计模式》的�W�一条设计准则。分开接口与实现的目标是要隔离变化。��Y件是变化的，如果不能把变化的东西隔离开来，��D��牵一发而动全��n�Q�代��h��巨大的。这是大家所不愿看到的�?/p>

C语言既然可以实现面向对象的编�E�，自然可以利用设计模式来分��L��口与实现。像桥接模式、策略模式、状态模式、代理模式等�{�，在C语言中，无一不需要利用函数指针来实现�?/p>

与松耦合原则有关。面向过�E�与面向对象相比�Q�之所以显得苍白无力，原因之一��是它不像面向对象一��P��可以直观的把现实模型映射到计��机中。面向过�E�讲的是层层控制�Q�而面向对象更��的对象间的分工合作。现实世界中的对象处于层�ơ关�pȝ��较少�Q�处于对�{�关�pȝ��居多。也��是��_��对象间的交互往往是双向的。这会加强对象间的耦合性�?/p>

耦合本��n没有错，实际上耦合是必不可��的�Q�没有耦合��没有协作，对象之间无法形成一个整体，什么事也做不了。关键在于耦合要恰当，在实现预定功能的前提下，耦合要尽可能的松散。这��P��pȝ��的一部分变化对其它部分的影响会很��?/p>

函数指针是解耦对象关�pȝ��最佛_��器。Signal(如boost的signal和glib中的signal)机制是一个典型的例子�Q�一个对象自�w�的状态可能是在变化的�Q�或者会触发一些事�Ӟ��Q�而其它对象关心它的变化。一旦该对象有变化发生，其它对象要执行相应的操作�?/p>

如果该对象直接去调用其它对象的函敎ͼ�功能是完成了�Q�但对象之间的耦合太紧了。如何把�q�种耦合降到最低呢�Q�signal机制是很好的办法。它的原理大致如下：其它��x��该对象变化的对象��d��注册一个回调函数到该对象中。一旦该对象有变化发生，��p��用这些回调函数通知其它对象。功能同样实��C��Q�但它们之间的耦合度降低了�?/p>

在C语言中，要解决以上这些问题，不采用函数指针，��是非常困难的。在�~�程中，如果你从没有惛_��用函数指针，很难惛_��你是一个C语言高手�?/p>

漫步者�?…�?�K?/a> 2009-04-19 20:49 发表评论

Sun, 19 Apr 2009 12:44:00 GMT

1) int型变量��@环左�U�k�ơ，即a=a < >16-k (设sizeof(int)=16)
(2) int型变量a循环右移k�ơ，即a=a>>k |a < <16-k (设sizeof(int)=16)
(3)整数的��^均�?
对于两个整数x,y�Q�如果用 (x+y)/2 求��^均��|��会��生溢出，因�ؓ x+y 可能会大于INT_MAX�Q�但是我们知道它们的�q�_��值是肯定不会溢出的，我们用如下算法：
int average(int x, int y) //�q�回X,Y 的��^均�?
{
    return (x&y)+((x^y)>>1);
}
(4)判断一个整数是不是2的幂,对于一个数 x >= 0�Q�判断他是不�?的幂
boolean power2(int x)
{
    return ((x&(x-1))==0)&&(x!=0)�Q?
}
(5)不用temp交换两个整数
void swap(int x , int y)
{
    x ^= y;
    y ^= x;
    x ^= y;
}
(6)计算�l�对�?
int abs( int x )
{
int y ;
y = x >> 31 ;
return (x^y)-y ;        //or: (x+y)^y
}
(7)取模�q�算转化成位�q�算 (在不产生溢出的情况下)
        a % (2^n) �{��h�?a & (2^n - 1)
(8)乘法�q�算转化成位�q�算 (在不产生溢出的情况下)
        a * (2^n) �{��h�?a < < n
(9)除法�q�算转化成位�q�算 (在不产生溢出的情况下)
        a / (2^n) �{��h�?a>> n
        �? 12/8 == 12>>3
(10) a % 2 �{��h�?a & 1
(11) if (x == a) x= b;
　　          else x= a;
　　      �{��h�?x= a ^ b ^ x;
(12) x �?相反�?表示�?(~x+1)

(13)求从x位（高）到y位（低）间共有多��个1

public static int FindChessNum(int x, int y, ushort k)
        {
            int re = 0;
            for (int i = y; i <= x; i++)
            {
                re += ((k >> (i - 1)) & 1);
            }
            return re;
        }
(14)
/*��?2位数分解�?�?位数处理后再合成32位数�q�回*/
DWORD GetDW(DWORD dw)
{
DWORD dwRet=0;
if (dw!=0)
{
  BYTE b1=(dw>>24)&0xff,b2=(dw>>16)&0xff,b3=(dw>>8)&0xff,b4=dw&0xff;
  //分别处理 b1,b2,b3,b4
  dwRet=b1;
  dwRet=(dwRet<<8)+b2;
  dwRet=(dwRet<<8)+b3;
  dwRet=(dwRet<<8)+b4;

  return dwRet;
}
else{
  return 0;
}
}

  ��一个无�W�号数是不�ؓ2^n-1(^为幂)�Q?nbsp;  x&(x+1)

  ��最右侧0位改�?位：   x   |   (x+1)

  二进制补码运��公式：
  -x   =   ~x   +   1   =   ~(x-1)
  ~x   =   -x-1
  -(~x)   =   x+1
  ~(-x)   =   x-1
  x+y   =   x   -   ~y   -   1   =   (x|y)+(x&y)
  x-y   =   x   +   ~y   +   1   =   (x|~y)-(~x&y)
  x^y   =   (x|y)-(x&y)
  x|y   =   (x&~y)+y
  x&y   =   (~x|y)-~x

  x==y:         ~(x-y|y-x)
  x!=y:         x-y|y-x
  x<   y:         (x-y)^((x^y)&((x-y)^x))
  x<=y:         (x|~y)&((x^y)|~(y-x))
  x<   y:         (~x&y)|((~x|y)&(x-y))//无符号x,y比较
  x<=y:         (~x|y)&((x^y)|~(y-x))//无符号x,y比较


  使用位运��的无分支代码：

  计算�l�对�?nbsp;
  int   abs(   int   x   )
  {
  int   y   ;
  y   =   x   >>   31   ;
  return   (x^y)-y   ;//or:   (x+y)^y
  }

  �W�号函数�Q�sign(x)   =   -1,   x<0;   0,   x   ==   0   ;   1,   x   >   0
  int   sign(int   x)
  {
  return   (x>>31)   |   (unsigned(-x))>>31   ;//x=-2^31时失�?^为幂)
  }

  三值比较：cmp(x,y)   =   -1,   x   y
  int   cmp(   int   x,   int   y   )
  {
  return   (x>y)-(x-y)   ;
  }

  doz=x-y,   x>=y;   0,   x  int   doz(int   x,   int   y   )
  {
  int   d   ;
  d   =   x-y   ;
  return   d   &   ((~(d^((x^y)&(d^x))))>>31)   ;
  }

  int   max(int   x,   int   y   )
  {
  int   m   ;
  m   =   (x-y)>>31   ;
  return   y   &   m   |   x   &   ~m   ;
  }

  不��用第三方交换x,y:
  1.x   ^=   y   ;   y   ^=   x   ;   x   ^=   y   ;
  2.x   =   x+y   ;   y   =   x-y   ;   x   =   x-y   ;
  3.x   =   x-y   ;   y   =   y+x   ;   x   =   y-x   ;
  4.x   =   y-x   ;   x   =   y-x   ;   x   =   x+y   ;

  双��g��?x   =   a,   x==b;   b,   x==a//常规�~�码为x   =   x==a   ?   b   :a   ;
  1.x   =   a+b-x   ;
  2.x   =   a^b^x   ;

  下舍入到2的k�ơ方的倍数:
  1.x   &   ((-1)<  2.(((unsigned)x)>>k)<  上舍入：
  1.   t   =   (1<  2.t   =   (-1)<
  位计�?�l�计1位的数量�Q?nbsp;
  1.
  int   pop(unsigned   x)
  {
  x   =   x-((x>>1)&0x55555555)   ;
  x   =   (x&0x33333333)   +   ((x>>2)   &   0x33333333   )   ;
  x   =   (x+(x>>4))   &   0x0f0f0f0f   ;
  x   =   x   +   (x>>8)   ;
  x   =   x   +   (x>>16)   ;
  return   x   &   0x0000003f   ;
  }
  2.
  int   pop(unsigned   x)   {
  static   char   table[256]   =   {   0,1,1,2,   1,2,2,3,   ....,   6,7,7,8   }   ;
  return   table[x&0xff]+table[(x>>8)&0xff]+table[(x>>16)&0xff]+table[(x>>24)]   ;
  }

  奇偶性计��?
  x   =   x   ^   (   x>>1   )   ;
  x   =   x   ^   (   x>>2   )   ;
  x   =   x   ^   (   x>>4   )   ;
  x   =   x   ^   (   x>>8   )   ;
  x   =   x   ^   (   x>>16   )   ;
  �l�果中位于x最低位�Q�对无符号x,�l�果的第i位是原数�W�i位到最左侧位的奇偶�?nbsp;


  位反转：
  unsigned   rev(unsigned   x)
  {
  x   =   (x   &   0x55555555)   <<   1   |   (x>>1)   &   0x55555555   ;
  x   =   (x   &   0x33333333)   <<   2   |   (x>>2)   &   0x33333333   ;
  x   =   (x   &   0x0f0f0f0f)   <<   4   |   (x>>4)   &   0x0f0f0f0f   ;
  x   =   (x<<24)   |   ((x&0xff00)<<8)   |   ((x>>8)   &   0xff00)   |   (x>>24)   ;
  return   x   ;
  }

  递增位反转后的数�Q?nbsp;
  unsigned   inc_r(unsigned   x)
  {
  unsigned   m   =   0x80000000   ;
  x   ^=   m   ;
  if(   (int)x   >=   0   )
  do   {   m   >>=   1   ;   x   ^=   m   ;   }   while(   x   <   m   )   ;
  return   x   ;
  }

  混选位�Q?nbsp;
  abcd   efgh   ijkl   mnop   ABCD   EFGH   IJKL   MNOP->aAbB   cCdD   eEfF   gGhH   iIjJ   kKlL   mMnN   oOpP
  unsigned   ps(unsigned   x)
  {
  unsigned   t   ;
  t   =   (x   ^   (x>>8))   &   0x0000ff00;   x   =   x   ^   t   ^   (t<<8)   ;
  t   =   (x   ^   (x>>4))   &   0x00f000f0;   x   =   x   ^   t   ^   (t<<4)   ;
  t   =   (x   ^   (x>>2))   &   0x0c0c0c0c;   x   =   x   ^   t   ^   (t<<2)   ;
  t   =   (x   ^   (x>>1))   &   0x22222222;   x   =   x   ^   t   ^   (t<<1)   ;
  return   x   ;
  }

  位压�~�：
  选择�q�右�U�d��x中对应于掩码m�?位的�?如：compress(abcdefgh,01010101)=0000bdfh
  compress_left(x,m)操作与此�c�M��Q�但�l�果位在左边:   bdfh0000.
  unsigned   compress(unsigned   x,   unsigned   m)
  {
  unsigned   mk,   mp,   mv,   t   ;
  int   i   ;

  x   &=   m   ;
  mk   =   ~m   <<   1   ;
  for(   i   =   0   ;   i   <   5   ;   ++i   )   {
  mp   =   mk   ^   (   mk   <<   1)   ;
  mp   ^=   (   mp   <<   2   )   ;
  mp   ^=   (   mp   <<   4   )   ;
  mp   ^=   (   mp   <<   8   )   ;
  mp   ^=   (   mp   <<   16   )   ;
  mv   =   mp   &   m   ;
  m   =   m   ^   mv   |   (mv   >>   (1<  t   =   x   &   mv   ;
  x     =   x   ^   t   |   (   t   >>   (   1<  mk   =   mk   &   ~mp   ;
  }
  return   x   ;
  }


  位置换：
  �?2�?位数表示从最低位开始的位的目标位置�Q�结果是一�?2*5的位矩阵�Q?nbsp;
  ��该矩阵沿次对角�U��{�|�后�?�?2位字p[5]存放�?nbsp;
  SAG(x,m)   =   compress_left(x,m)   |   compress(x,~m)   ;
  准备工作�Q?nbsp;
  void   init(   unsigned   *p   )   {
  p[1]   =   SAG(   p[1],   p[0]   )   ;
  p[2]   =   SAG(   SAG(   p[2],   p[0]),   p[1]   )   ;
  p[3]   =   SAG(   SAG(   SAG(   p[3],   p[0]   ),   p[1]),   p[2]   )   ;
  p[4]   =   SAG(   SAG(   SAG(   SAG(   p[4],   p[0]   ),   p[1])   ,p[2]),   p[3]   )   ;
  }
  实际�|�换�Q?nbsp;
  int   rep(   unsigned   x   )   {
  x   =   SAG(x,p[0]);
  x   =   SAG(x,p[1]);
  x   =   SAG(x,p[2]);
  x   =   SAG(x,p[3]);
  x   =   SAG(x,p[4]);
  return   x   ;
  }

  二进制码到GRAY码的转换:
  unsigned   B2G(unsigned   B   )
  {
  return   B   ^   (B>>1)   ;
  }
  GRAY码到二进制码:
  unsigned   G2B(unsigned   G)
  {
  unsigned   B   ;
  B   =   G   ^   (G>>1)   ;
  B   =   G   ^   (G>>2)   ;
  B   =   G   ^   (G>>4)   ;
  B   =   G   ^   (G>>8)   ;
  B   =   G   ^   (G>>16)   ;
  return   B   ;
  }

  扑և�最�?字节的位�|?
  int   zbytel(   unsigned   x   )
  {
  static   cahr   table[16]   =   {   4,3,2,2,   1,1,1,1,   0,0,0,0,   0,0,0,0   }   ;
  unsigned   y   ;
  y   =   (x&0x7f7f7f7f)   +   0x7f7f7f7f   ;
  y   =   ~(y|x|0x7f7f7f7f)   ;
  return   table[y*0x00204081   >>   28]   ;//乘法可用�U�M��和加完成
  }

C\C++支持比较低阶的位�q�算�Q�在是众人皆知的了。每本C\C++的教�U�书都会说到�q�部分的内容�Q�不�q�都很简略，我想会有很多��Z��知道位运��用在什么地斏V��这个帖子就��略说说位�q�算的用处，更进一步的用法要大家自己去体会。而主要说的是操作标志值方面�?/p>

/****************************************/

#define BTI_MSK(bit)    (1 << (bit))
#define BIT_SET(x,bit)  ((x) |=  BTI_MSK (bit))
#define BIT_CLR(x,bit)  ((x) &= ~BTI_MSK (bit))
#define BIT_TST(x,bit)  ((x) &   BTI_MSK (bit))

/****************************************/

考虑一个事物、一个系�l�、或者一个程序可能会出现一�U�或者几�U�状态。�ؓ了在不同的状态下�Q�作��Z��同的行�ؓ�Q�你可以讄��一些标志��|��再根据标志值来做判断。比如C++的文件流�Q�你��可以设定一些标志��|��ios::app, ios::ate, ios::binary, ios::in, ios::out, ios::trunc�Q��ƈ且可以将它用|�l�合��h��创徏一个恰当的文�g��。你可能会将�q�些标志值定义�ؓbool�c�d��Q�不�q�这栯��是设�|�的标志��g��多，��׃��很浪费空间�?br>
而假如定义一个整型数��|��unsigned int flags; 在现在的�pȝ��Q�flags应该�?2�? �?,2,3....32��位�q�行�~�号�Q�我们可以进行这��L��判断, 当位1�?�Ӟ��表示用读方式打开文�g�Q�当�?�?�Ӟ��表示用写方式打开文�g�Q�当�?�?�Ӟ��用二�q�制方式打开文�g....因�ؓflags�?2位，��可以设�|?2个不同的状态��|��也相当于32个bool�c�d��。这样一斚w��省了�I�间, 另一斚w��也多了个好处�Q�就是如前面所说的�Q�可以将标志值组合�v来�?br>//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

好啦�Q�上面有点不清不楚的。下面看看到底怎么操作�q�些标志倹{�?br>设想C++的类ios�q�样定义, 其实没有�q�个�c�，只有ios_basic�c�，typedef basic_ios ios;

class ios
{
public:
    enum {    app = 0x0001, ate = 0x0002, binary = 0x0004,
        in = 0x0008,  out = 0x0010, trunc = 0x0020 };
    ....
private:
    unsigned int flags;
};

注意上面enum语句中，每一个数值只�?位是1�Q�其余是0�Q�这个很重要�Q�你可以��它化成2�q�制看看�?br>
现在��flags相应的位讄��?, 可以�q�样�?nbsp;flags |= app。这个等于flags = flags | app, ��Z��么呢? app只有1位是1�Q�其余是0�Q�因�? | 1 = 0�Q?nbsp;0 | 0 = 0�Q?nbsp;�q�样0对应的位是不变的。�? | 1 = 1, 1 | 0 = 1, 1对应的位不论原来是什么状态，都一定�ؓ1。如果想要将几个位都讄��?�Q�可以这样做 flags |= (app | ate | binary)。因为每个enum常数各有一位�ؓ1, 与运��之后就�?位�ؓ1�Q�就如上面的分析�Q�就可以��那3位都讄��?, 其余位不变。这个就是标志可以组合�v来用的原因。也可以�?�l�合��h��Q�原因在�?下面的数字是2�q�制)0001 + 0010 + 0100 = 0111 跟与�q�算�l�果一栗��不�q�不提倡用+, 考虑(app | ate | binary)要是我不��心写多了个标志��|��(app | ate | ate | binary)�l�果�q�是正确的，如果�?的话�Q�就会��生进位，�l�果��׃��错误。通常我们不知道原先已�l�组合了多少个标志��g��Q�用或运��会安全�?br>
现在��flags对应的位讄��?, 可以�q�样�?nbsp;flags &= ~app。相当于 flags = flags & (~app). app取反之后�Q�只�?位是0�Q�其余是1�Q�做与运��之后，1对应的位�q�不会改变，0对应的�ؓ不管原来�?�?�Q�都肯定�?�Q�这样就��对应的位设�|�了0。同样同时设�|�几个标志位可以�q�样做，flags &= ~(app | ate | binary)�?br>
现在��flags对应的位�Q�如果是1��变�?�Q�如果是0��变�?�Q�可以这样做 flags ^= app。同时设�|�几个标志位可以写成 flags ^= (app | ate | binary)。不再做分析了，不然��太�|�嗦了。不�q�也�l�大家一个例子，你查查Ascii表，会发现对应的大小写字母是相差倒数�W?位，可以用这��L��函数�l�一的将大写变成��写�Q�小写变成大写�?br>void xchgUppLow(string& letters)
{
        const unsigned int mask = (1<<5);

        for (size_t i=0; i                letters[i] ^= mask;
}
前提是输入的string一定要全是字母, 而要��x��操作字母�Q�可以在原来基础上加个判断�?br>
好啦�Q�上面已�l�可以设�|�flags的对应位��g��Q�要是判断呢�Q�可以这样写 if (flags & app) �q�样可以判断对应的位值是否�ؓ1, 因�ؓC\C++语言中非0��q��。app只有一位是1�Q�其余是0�Q�如�? flags的对应位也是0�Q�在与操作下��得到结�?�Q�反之非0�Q�这样就可以判断标志位了�?br>
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
上面关于标志值的操作��׃��l�完毕。其实在C++中已�l�有了个bitset了，没有必要去自��p��行低阶的位运��，上面的四个操作在bitset中分别叫做set, reset, flip, test。不�q�在C中，�q�样的代码还很常�? 反正知道多点也没有坏处�?br>
�?nbsp;windows API �~�程�Q�你也经�怼��到�q�样的标志��|��要互相组合，可以用|, 也可以用+(只是��用|�Q�理�׃��面说�?. 它的标志��g��是这样定义的�Q�不�q�用#define
#define WS_BORDER    0x0001
#define WS_CAPTION    0x0002
......
当初我就是想不明白�ؓ什么可以用|或者用+来组合，现在知道了�?br>
(注：上面出现的数字是我自�׃��的，到底实际怎么定义其实没有关系�Q�只要保证只有一位是1�Q�其余是0��可以的�? 因�ؓ�~�程的时候用的是帔R��|��没有��L��ȝ��接用数值的)

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
其实�Q�位�q�算�q�有很多用处。比如移位相当于乘除2的幂�?不过通常�~�译器也��乘�?的幂��C��化成汇编的移位指令，所以没有必要不要这样卖弄了。汇�~�的�U�M��指��o有两�l�，分别针对有符号和无符��L��, 我猜惛_��C\C++的同一�U�M��q�算针对有符��h��数和无符��h��数的不同�Q�会�Ҏ��情况�~�译成不同的汇编�U�M��指��o�Q�不�q�没有去证实), 其实�U�M��更用得多的地�Ҏ��L��造一个掩�? 比如上面的mask = (1<<5);

�q�有&�q�算�Q�有时候可以用来求余数。比�?nbsp;value & (1<<4 - 1) �q�相当于��value的高位全变成0了，效果�{�于 value % 8.

�q�有值得一提的是^�q�算�Q�它有个很特�D�的性质。比�?nbsp;A ^= B, 变成另一个数�Q�跟着再执行A ^= B�Q�又变回原来的数了，不信你可以列真��D��或者化��逻辑式看看。就因�ؓ�q�个性质�Q�^有很多用途。比如加密，你将原文看成A, 用同一个B异或一�ơ，��q��当于加密�Q�跟着在用B异或一�ơ，相当于解密。不�q�这��h��很容易破解就是了。要是一个B不够�Q�还可以加个C, 比如A ^= B, A ^= C, A ^= C, A ^= B, 恢复原状�?br>
下面一个小�E�序�Q�用异或交换两个数字�?br>int x = 3;
int y = 4;

x ^= y;
y ^= x;
x ^= y;

其实何止交换数字�Q�连交换对象也可以的
template
void swap(T& obj1, T& obj2)
{
        const int sizeOfObj = sizeof(T);
        char* pt1 = (char*)&obj1;
        char* pt2 = (char*)&obj2;

        for (size_t i=0; i        {
                pt1[i] ^= pt2[i];
                pt2[i] ^= pt1[i];
                pt1[i] ^= pt2[i];
        }
}

�q�有异或操作�q�可以用在图象的光栅操作。我们知道，颜色也是用二�q�制来表�C�的�Q�对颜色�q�行不同的位�q�算�Q�就可以得到不同的光栅。因为异或的�Ҏ��性质�Q�我们用异或操作的光栅画了副图，跟着再在原来的地方画一�ơ，那副囑ְ�刷除了。这样可以用来显�C�动画而不用保存原来的��d��信息。以前我写过个双人的贪食蛇，��q��了异或光栅。因��景色是白色的�Q�也��是�?�Q�作A ^ 1 = A, 所以用��d��M��ơ是��M��讑֮�的颜�Ԍ��再画一�ơ就恢复。最有趣的是两蛇�怺�的时候，颜色也会作异或叠加，产生一�U�新的颜色了�Q�离开的时候也会自动恢复�?br>//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
好啦�Q�够长了�Q�就停止吧。在最后再�l�大家一�D�代码，是用来看看对象在内存中的位值的。可以看看�?br>string bitsOfUChar(unsigned char c)
{
        const int numOfBitsInUChar = 8;
        unsigned int mask = (1<<7);
        string result(8, '0');

        for (size_t i=0; i        {
                if ( mask & c)
                        result[i] = '1';

                mask >>= 1;
        }

        return result;
}

template
string bitsInMemory(const T& obj)
{
        int sizeOfObj = sizeof(obj);
        unsigned char* pt = (unsigned char*)&obj;
        string result;

        for (size_t i=0; i        {
                result += bitsOfUChar(pt[i]);
                result += ' ';
        }

        return result;
}

比如bitsInMemory(12)�Q�会输出00001100 00000000 00000000 00000000, 我就知道我自��q��机器是小��N��序的了�?br>

漫步者�?…�?�K?/a> 2009-04-19 20:44 发表评论

国产精品一区二区三区成人,久久国产精品久久久久久电车,国产欧美激情

SDI Minimize and Maxinum flash windw

Why the flash occurs

The solution

AfxMessageBoxFormatted and MessageBoxFormatted

函数指针

What are TCHAR, WCHAR, LPSTR, LPWSTR, LPCTSTR etc?

�Q��{�Q�C、C++ 旉���

C++ 旉���

Debug函数的实玎ͼ�转）

�Q��{�Q�C、C++ 旉��

C++ 旉��