45 天系列：CodeProject VC++ 论坛问答 - V

MFC

WINDOW32

通用

有趣

答案

MFC

    CStringA strFormat;
    // For Integer

    strFormat.Format("%d",10);
    // For Float

    strFormat.Format("%f",10.05);
   

    CStringW strFormat;
    // For Integer
    strFormat.Format(L"%d",10);
    // For Float

    strFormat.Format(L"%f",10.05);
    

 CFont *m_Font1 = new CFont();
CStatic *staticCtl =(CStatic *) GetDlgItem(IDC_STATIC1);
m_Font1->CreatePointFont(100,_T("Arial")); 
staticCtl->SetFont(m_Font1);

COleDateTime dt("9/24/2008");
CString dayNameLong = dt.Format("%A");
CString dayNameShort = dt.Format("%a"); 

因为MFC就是这样设计的。这个对象封装了所有Windows应用程序只有一个的应用程序实例信息，例如HINSTANCE和传递的命令行参数。它还保存了任何其他只能有一个的应用程序范围的设置。这使得它成为一个很好的地方来隐藏应用程序范围的变量，这些变量在过去是全局变量。

因为它应用程序类的基类。一个应用程序不需要多个应用程序类。实现依赖于从AfxGetApp()获得的全局对象，该对象由winMain中的AfxWinMain使用。那么这类似于问为什么一个应用程序只有一个main函数。

“MFC中的主应用程序类封装了Windows操作系统的应用程序的初始化、运行和终止。基于该框架构建的应用程序必须且只能有一个从CWinApp派生的类的对象。”引自msdn。

(m_pic.GetDC())->SetBkMode(TRANSPARANT);
(m_pic.GetDC())->TextOut(0,0,"hello");

    CTimeSpan sPan(0,0,0, 86400 );// 1 day 
   CTime CurTime = CTime::GetCurrentTime(); 
   CurTime +=sPan; 
   CString csTime = CurTime.Format(_T("%A, %B %d, %Y")); 
    
   AfxMessageBox(csTime );
    

WINDOW32

    TCHAR tcPath[MAX_PATH];
    GetEnvironmentVariable( _T("PUBLIC"), tcPath, MAX_PATH );

    extern "C" {
    __declspec(dllexport) int MyFunc ( int A ) { return(A*2); }
    }
    
    and in .def (in EXPORTS):
    MyFunc @3
    
    'DumpBin /exports mydll.lib' will report '_MyFunc' as the name.
    
    If, we used:
    extern "C" {
    __declspec(dllexport) int __stdcall MyFunc ( int A ) { return(A*2); }
    }
    

#include <windows.h>

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
char szClassName[ ] = "CodeBlocksWindowsApp";

int WINAPI WinMain (HINSTANCE hThisInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR lpszArgument,
                     int nCmdShow)
{
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);

    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default colour as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           "Code::Blocks Template Windows App",       /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           544,                 /* The programs width */
           375,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );

    /* Make the window visible on the screen */
    ShowWindow (hwnd, nCmdShow);

    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}



// frees you from using the GDI function, which requires a region
void GradientFillRect(HDC hdc, LPRECT rcGradient, COLORREF start, COLORREF end, BOOL isVertical)
{
	BYTE startRed = GetRValue(start);
	BYTE startGreen = GetGValue(start);
	BYTE startBlue = GetBValue(start);

	BYTE endRed = GetRValue(end);
	BYTE endGreen = GetGValue(end);
	BYTE endBlue = GetBValue(end);

	HBRUSH endColor = CreateSolidBrush(end);
	FillRect(hdc, rcGradient, endColor);
	DeleteObject(endColor);

	//Gradient line width/height
	int dy = 1;

	int length = (isVertical ? rcGradient->bottom - rcGradient->top : rcGradient->right - rcGradient->left) - dy;

	for (int dn = 0; dn >= length; dn += dy)
	{
		BYTE currentRed = (BYTE)MulDiv(endRed-startRed, dn, length) + startRed;
		BYTE currentGreen = (BYTE)MulDiv(endGreen-startGreen, dn, length) + startGreen;
		BYTE currentBlue = (BYTE)MulDiv(endBlue-startBlue, dn, length) + startBlue;

		RECT currentRect = {0};
		if (isVertical)
		{
			currentRect.left = rcGradient->left;
			currentRect.top = rcGradient->top + dn;
			currentRect.right = currentRect.left + rcGradient->right - rcGradient->left;
			currentRect.bottom = currentRect.top + dy;
		}
		else
		{
			currentRect.left = rcGradient->left + dn;
			currentRect.top = rcGradient->top;
			currentRect.right = currentRect.left + dy;
			currentRect.bottom = currentRect.top + rcGradient->bottom - rcGradient->top;
		}

		HBRUSH currentColor = CreateSolidBrush(RGB(currentRed, currentGreen, currentBlue));
		FillRect(hdc, &currentRect, currentColor);
		DeleteObject(currentColor);
	}
}


/*  This function is called by the Windows function DispatchMessage()  */
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    RECT myRect;
    COLORREF startCol = RGB(71,71,71), endCol = RGB(200,200,200);

    switch (message)                  /* handle the messages */
    {
        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        case WM_ERASEBKGND:
            GetClientRect(hwnd, &myRect);
            GradientFillRect(HDC (wParam), &myRect, startCol, endCol, false);
            return 1;                           // indicate that WM_ERASEBKGND was handled

        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }
    return 0;
}

  CString CStr = ...; 
  LPTSTR pTCharStr = new  TCHAR[CStr.GetLength() + 1];
 
  _tcscpy_s(pTCharStr, CStr.GetLength() + 1, CStr); 

     #include <string>... 
     CString CStr = ...;
     #if defined(_UNICODE) 
            wstring stdstr = CStr;
      #else 
            string stdstr = CStr;
      #endif 
    

HKEY hKey = NULL; 
string MyChoiceVariable; 
if (ERROR_SUCCESS != RegOpenKeyEx(
    HKEY_LOCAL_MACHINE, 
    "SOFTWARE\\..", 
    0,
    KEY_QUERY_VALUE,
    &hKey ))
 { 
  MyChoiceVariable = "KEY DOES NOT EXIST"; 
  
  cout << MyChoiceVariable << endl; 
 } 
 
 if (ERROR_SUCCESS == RegOpenKeyEx( 
    HKEY_LOCAL_MACHINE, 
    "SOFTWARE\\..", 
    0,
    KEY_QUERY_VALUE,
    &hKey ))
    { 
      MyChoiceVariable = "KEY EXISTS"; 
      cout << MyChoiceVariable << endl;
    } 
    

使用 GetScrollInfo，将滚动量(lpsi->nPos)添加到检索到的客户坐标中。希望这有帮助！

滚动窗口与它所附加的窗口没有实际关系。以记事本为例。每次您单击滚动条上的向上箭头时，文本会移动一行。所以像素量会根据字体大小而变化。这对某些外部程序来说是不可用的。当程序使用滚动条并被要求绘制窗口时，它会获取滚动位置，并根据自己的喜好解释它。它们如何做到这一点将取决于应用程序...

要利用rundll32.exe，您导出的函数必须遵循一些规则，例如原型必须如下所示：-

CALLBACK MsgBoxW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow); 那么一个可用的示例（至少在XP上有效...）将是

void CALLBACK MsgBoxW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)
{ 
    MessageBox(hwnd, lpszCmdLine, L"MyMessageBox", MB_OK);
}

GetSystemDefaultLangID() 返回系统区域设置。它用于确定非Unicode（也称为“ANSI”）文本使用的代码页。它可以在（XP上）通过控制面板中“区域和语言选项”的“高级”选项卡进行更改（可能需要重新启动才能生效）。GetUserDefaultUILanguage() 返回当前UI语言，如果安装了MUI包，用户可以设置该语言。

尝试 GetProcessMemoryInfo()

通用

• https://codeproject.org.cn/KB/COM/jscalls.aspx[^]
• http://www.digitalmars.com/d/archives/digitalmars/DMDScript/169.html[^]
• http://www.google.com/search?num=30&hl=en&safe=off&q=call+js+%28function+OR+method%29+from+C%2B%2B&btnG=Search[^]

1. 在程序的最开头添加 InitCommonControls() 调用。
2. 在stdafx.h文件中，添加此行：#include "commctrl.h" 在您的项目属性中
3. 在“链接器/清单文件”中，确保“生成清单”条目设置为“是”
4. 在“链接器/命令行”中添加 "comctl32.lib" (不带引号)。
5. 在“清单工具/输入和输出”中，将 “附加清单文件” 设置为 $(IntDir)\XPCommonControls.manifest

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestversion="1.0">
     <dependency>
          <dependentassembly>
               <assemblyidentity>
                    type="win32"
                    name="Microsoft.Windows.Common-Controls"
                    version="6.0.0.0"
                    processorArchitecture="X86"
                    publicKeyToken="6595b64144ccf1df"
                    language="*"/>

    FILE * fpin = fopen("MyBinaryFile.foo","rb");
    FILE * fpout = fopen("MytextFile.txt","w");
    int c;
    int count = 0;
    while ( (c=getc(fpin)) != EOF )
    {
     fprintf(fpout, "%02x ", c);
      if (count % 16 == 15) fprintf(fpout, "\n"); 
      
     count++;
    }
    
    fclose(fpin);
    fclose(fpout);
    

1. 选择一个地方存储日期（注册表、文件等）
2. 当应用程序启动时，检查该位置的日期
3. 如果没有找到日期，则将当前日期存储在那里
4. 如果找到日期，则从存储的日期中减去当前日期。
5. 将差值与您的时间限制进行比较。像这样的方案存在巨大的明显漏洞（找到日期并删除它以重置试用期）。但是，它们确实有效。

请告诉我这个程序是如何工作的...我将一个指向类的指针设置为零，但只要我不访问任何实例变量，我仍然可以访问实例成员。

       #include "stdafx.h" 
       #include <stdio.h>
       
       class A 
       { 
       public: 
        int i; 
        void PrintMe(); 
       };
        void A::PrintMe() 
        {
         printf("Hello World\n");
        } 
        
        void main() 
        { 
            A* p = 0; 
            p->PrintMe(); 
        }
    

A::PrintMe函数不访问类成员，也不是虚函数，因此不使用this指针。这是完全合法的。

在p上调用方法实际上并没有解引用p，它只是将this设置为p的值。如果PrintMe()解引用了this，例如访问非静态数据成员，那么代码就会崩溃。

__declspec(dllexport) int g_iYourVariable;

__declspec(dllimport) int g_iYourVariable;

     char cArr[] = { '1', '2', '\0', '3', '\0', '4', 
    '5', '\0' }; 
    
    BSTR MyBstr = ::SysAllocStringByteLen(cArr, sizeof(cArr));
    _bstr_t  bstrSend(MyBstr, true);
    

1. 如果您使用的是VS2005，请从项目属性中获取项目名称的值，vsproperty->c/c++->预处理器->预处理器定义：PROJECT_NAME=$(ProjectName)
2. 现在在您的代码中使用上面的PROJECT_NAME宏，

        #define STRINGIZE(_x) #_x
        #define STRINGIZEVALUE(_x) STRINGIZE(_x)
        
        char projectName[]= STRINGIZEVALUE(PROJECT_NAME);
       

// IsOnStack.cpp：定义控制台应用程序的入口点。//

        #include "stdafx.h"
        #include <iostream>
        #include <windows.h>
        using namespace std; 
        
        bool IsOnStack(const void *pData)
        { 
            DWORD StackBase; 
            DWORD StackLimit; 
            __asm { 
                    MOV EAX, DWORD PTR FS:[0x04] 
                    MOV StackBase, EAX 
                    MOV EAX, DWORD PTR FS:[0x08] 
                    MOV StackLimit, EAX 
                   } 
            
            DWORD Address = reinterpret_cast<DWORD>(pData); 
            return   (Address >= StackLimit) && (Address < StackBase);
        } 
        
        const char* PrintStack(const void *pData)
        { 
            return IsOnStack(pData) ? ": Stack" : ": Not on Stack";
        } 
        
        int main(int argc, char* argv[])
        { 
             const char *pString1 = "String1"; 
             cout << pString1<< 
             
             PrintStack(pString1) << endl; 
             char String2[] = "String2"; 
             cout << String2 << 
             PrintStack(String2) << endl; 
             return 0;
         }
        

输出是
字符串1：不在栈上
字符串2：栈上

“NFS 挂载”一词暗示了一个设备驱动程序。通常不建议在 C++ 中开发 Microsoft Windows 设备驱动程序，尽管可以做到。Microsoft 提供了 IFS Kit[ http://www.microsoft.com/whdc/DevTools/IFSKit/default.mspx[^]] 用于开发文件系统和文件系统过滤器。

但是，如果您只是想使用已有的东西（或者有一些常识），那么也许您可以使用 Microsoft Windows Services for UNIX[ http://technet.microsoft.com/en-us/interopmigration/bb380242.aspx[^]]。这个链接将为您提供一个开端。
http://www.openfree.org/pet/index.php/Mount_an_NFS_share_from_Windows[^]

#pragma once 指令指定文件在编译源代码文件时只被编译器包含一次。这可以减少构建时间，因为编译器在第一次包含模块后不会打开和读取该文件。

应用程序可以为 InternetOpen 实例使用不同的代理设置

    (HINTERNET) using InternetSetOption. [ BOOL InternetSetOption( __in HINTERNET 
    hInternet, __in DWORD dwOption, __in LPVOID lpBuffer, __in DWORD dwBufferLength 
    ); ^]
    

• http://gaskell.org/the-requested-operation-requires-elevation-in-windows-vista/[^]
• http://windowshelp.microsoft.com/windows/en-us/help/f941cb45-b2cd-4b39-ab87-cb9ea959f44e1033.mspx[^]

有趣

1. 当您的应用程序仍在运行时显示消息框。
2. 按下键盘上的Print Screen键。
3. 关闭您的应用程序。
4. 打开MS Paint。
5. 粘贴图像 ( CTRL + V )。
6. 享受您的消息框

关于多态性的轻松一面：-

教师对象在两个学生实例上调用LearnPolymorphism()方法。第一个实例，
比如cleverPupil，它实际上是CleverPupil的一个实例，调用readBook(goodOOPBook)来完成任务。
另一方面，第二个学生实例，比如lazyPupil，它是LazyPupil的一个实例，用自己的方式实现该方法，
通过调用startAsking(hereAndThere)...

CleverPupil和LazyPupil都继承自Pupil，因此教师能够在它们上面调用虚拟的Pupil方法
LearnPolymorphism()。但是，由于多态性，教师从它们那里获得了两个截然不同的结果。

• Rajesh R Subramanian
• Roger Stoltz
• cmk
• CPallini
• Michael Schubert
• PJ Arends
• ThatsAlok
• DavidCrow
• Naveen
• Michael Dunn
• cofi++
• Moak
• 迈克·奥尼尔
• SandipG
• Mark Salsbery
• Alain Rist
• J_E_D_I
• Maxwell Chen
• Iain Clarke
• Nibu babu thomas
• Rajkumar R
• Stephen Hewitt
• led mike