`

基于visual c++之windows核心编程代码分析（9）实现Windows服务并安装，控制

 
阅读更多 
//我们进行Windows编程的时候，经常涉及到Windows服务编程，针对Windows服务我们该怎么编程呢，
//我们先来实现一个Windows服务并实现之，请见注释代码分析。

/* 头文件　*/
#include <windows.h>     
/* 全局变量　*/
SERVICE_STATUS          SplSrvServiceStatus;      
SERVICE_STATUS_HANDLE   SplSrvServiceStatusHandle;      
/* 函数声明　*/
VOID SvcDebugOut(LPSTR String, DWORD Status);     
VOID WINAPI SplSrvServiceCtrlHandler (DWORD opcode);      
VOID WINAPI SplSrvServiceStart (DWORD argc, LPTSTR *argv);      
DWORD SplSrvServiceInitialization (DWORD argc, LPTSTR *argv,      
                                   DWORD *specificError);      
          
/*************************************    
* VOID WINAPI SplSrvServiceStart (DWORD argc, LPTSTR *argv)    
* 功能    服务启动函数    
*    
* 参数    未使用    
**************************************/
VOID WINAPI SplSrvServiceStart (DWORD argc, LPTSTR *argv)      
{      
    DWORD status;      
    DWORD specificError;      
    // 填充SERVICE_STATUS 结构     
    SplSrvServiceStatus.dwServiceType        = SERVICE_WIN32;      
    SplSrvServiceStatus.dwCurrentState            
        = SERVICE_START_PENDING;        // 服务在运行     
    SplSrvServiceStatus.dwControlsAccepted        
        = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE;      
    SplSrvServiceStatus.dwWin32ExitCode      = 0;      
    SplSrvServiceStatus.dwServiceSpecificExitCode = 0;      
    SplSrvServiceStatus.dwCheckPoint         = 0;      
    SplSrvServiceStatus.dwWaitHint           = 0;      
    // 注册服务控制请求处理例程     
    SplSrvServiceStatusHandle = RegisterServiceCtrlHandler(      
        "Sample_Srv",   // 服务名，在创建服务时使用了     
        // SERVICE_WIN32_OWN_PROCESS，因此本参数被忽略。     
        SplSrvServiceCtrlHandler);  // 控制请求处理例程，函数名     
          
    if (SplSrvServiceStatusHandle == (SERVICE_STATUS_HANDLE)0)      
    {      
        SvcDebugOut(" [SPLSRV_SERVICE] RegisterServiceCtrlHandler "
            "failed %dn", GetLastError());      
        return;      
    }       
    // 初始化工作，本示例未使用，函数为空     
    status = SplSrvServiceInitialization(argc,argv, &specificError);       
    // 初始化出错，用户自行修改     
    if (status != NO_ERROR)      
    {      
        SplSrvServiceStatus.dwCurrentState       = SERVICE_STOPPED;      
        SplSrvServiceStatus.dwCheckPoint         = 0;      
        SplSrvServiceStatus.dwWaitHint           = 0;      
        SplSrvServiceStatus.dwWin32ExitCode      = status;      
        SplSrvServiceStatus.dwServiceSpecificExitCode = specificError;      
          
        SetServiceStatus (SplSrvServiceStatusHandle, &SplSrvServiceStatus);      
        return;      
    }      
    // 初始化完成，设置运行状态     
    SplSrvServiceStatus.dwCurrentState       = SERVICE_RUNNING;      
    SplSrvServiceStatus.dwCheckPoint         = 0;      
    SplSrvServiceStatus.dwWaitHint           = 0;      
          
    if (!SetServiceStatus (SplSrvServiceStatusHandle, &SplSrvServiceStatus))      
    {      
        status = GetLastError();      
        SvcDebugOut(" [SPLSRV_SERVICE] SetServiceStatus error %ldn",status);      
    }      
    // 用户自行修改，用于完成服务的工作     
    SvcDebugOut(" [SPLSRV_SERVICE] Returning the Main Thread n",0);      
          
    return;      
}      
          
          
/*************************************    
* DWORD SplSrvServiceInitialization(DWORD   argc,     
*   LPTSTR  *argv,     
*   DWORD *specificError)    
* 功能    初始化，这里未进行任何工作，留待读者修改    
*    
* 参数        
**************************************/
DWORD SplSrvServiceInitialization(DWORD   argc,      
                                  LPTSTR  *argv,      
                                  DWORD *specificError)      
{      
    return(0);      
}     
          
/*************************************    
* VOID WINAPI SplSrvServiceCtrlHandler (DWORD Opcode)    
* 功能    服务控制请求的处理函数，与ControlService函数配合。    
*    
* 参数    服务控制码    
**************************************/
VOID WINAPI SplSrvServiceCtrlHandler (DWORD Opcode)      
{      
    DWORD status;      
    switch(Opcode)      
    {      
    case SERVICE_CONTROL_PAUSE:      
        // 完成相关功能     
        SplSrvServiceStatus.dwCurrentState = SERVICE_PAUSED;      
        break;      
    case SERVICE_CONTROL_CONTINUE:      
        // 完成相关功能     
        SplSrvServiceStatus.dwCurrentState = SERVICE_RUNNING;      
        break;      
    case SERVICE_CONTROL_STOP:      
        // 完成相关功能     
        SplSrvServiceStatus.dwWin32ExitCode = 0;      
        SplSrvServiceStatus.dwCurrentState  = SERVICE_STOPPED;      
        SplSrvServiceStatus.dwCheckPoint    = 0;      
        SplSrvServiceStatus.dwWaitHint      = 0;      
          
        if (!SetServiceStatus (SplSrvServiceStatusHandle,      
            &SplSrvServiceStatus))     
        {      
            status = GetLastError();      
            SvcDebugOut(" [SPLSRV_SERVICE] SetServiceStatus error %ldn",      
                status);      
        }       
        SvcDebugOut(" [SPLSRV_SERVICE] Leaving SplSrvService n",0);      
        return;      
    case SERVICE_CONTROL_INTERROGATE:      
        // 收到此请求后发出声响，演示服务控制请求的处理过程，读者可自行修改     
        MessageBeep(MB_OK);     
        break;      
    default:      
        SvcDebugOut(" [SPLSRV_SERVICE] Unrecognized opcode %ldn",      
            Opcode);      
    }      
    // 当前状态     
    if (!SetServiceStatus (SplSrvServiceStatusHandle,  &SplSrvServiceStatus))      
    {      
        status = GetLastError();      
        SvcDebugOut(" [SPLSRV_SERVICE] SetServiceStatus error %ldn",      
            status);      
    }      
    return;      
}     
/*************************************    
* void main( )     
* 功能    程序入口函数，注册服务启动函数等。    
*    
* 参数    服务控制码    
**************************************/
void main( )      
{      
    // 设置SERVICE_TABLE_ENTRY 数据结构，以NULL 结构结束，     
    // 作为StartServiceCtrlDispatcher 函数的参数。     
    SERVICE_TABLE_ENTRY   DispatchTable[] =      
    {      
        { "Sample_Srv", (LPSERVICE_MAIN_FUNCTION) SplSrvServiceStart },      
        { NULL, NULL }      
    };      
    if (!StartServiceCtrlDispatcher( DispatchTable))      
    {      
        SvcDebugOut(" [SPLSRV_SERVICE] StartServiceCtrlDispatcher (%d)n",      
            GetLastError());      
    }      
}      
/*************************************    
* VOID SvcDebugOut(LPSTR String, DWORD Status)     
* 功能    显示信息给调试器。    
*    
* 参数    LPSTR String    消息字符串    
*       DWORD Status    状态    
**************************************/
VOID SvcDebugOut(LPSTR String, DWORD Status)      
{      
    CHAR  Buffer[1024];      
    if (strlen(String) < 1000)      
    {      
        wsprintf(Buffer, String, Status);      
        OutputDebugString(Buffer);      
    }      
}




//具体实现代码如下，请见代码分析
**************************************/     
/* 头文件　*/
#include <windows.h>     
#include <tchar.h>     
#include <stdio.h>     
/* 全局变量　*/
SC_HANDLE schService;     
SC_HANDLE schSCManager;     
LPTSTR szServiceName = TEXT("Sample_Srv");     
          
/*************************************    
* BOOL CreateSampleService(LPTSTR szPath, LPSTR szServiceName)     
* 功能    创建服务    
*    
* 参数    
*       SC_HANDLE schSCManager，SCM句柄    
*       LPTSTR szPath， 服务程序的路径    
*       LPSTR szServiceName， 服务名    
**************************************/
BOOL CreateSampleService(      
                         SC_HANDLE schSCManager,     
                         LPTSTR szPath,     
                         LPSTR szServiceName)      
{      
    // 创建服务     
    schService = CreateService(      
        schSCManager,               // SCM 句柄     
        szServiceName,              // 服务名     
        "Service sample",           // 显示的服务名     
        SERVICE_ALL_ACCESS,         // 存取权限     
        SERVICE_WIN32_OWN_PROCESS,  // 服务类别     
        SERVICE_DEMAND_START,       // 启动类别     
        SERVICE_ERROR_NORMAL,       // 错误控制类别     
        szPath,                     // 服务的可执行文件路径     
        NULL,                       // no load ordering group      
        NULL,                       // no tag identifier      
        NULL,                       // no dependencies      
        NULL,                       // LocalSystem account      
        NULL);                      // no password      
          
    if (schService == NULL)      
    {     
        printf("CreateService failed (%d)n", GetLastError());      
        return FALSE;     
    }     
    else
    {     
        printf("CreateService succeededn");      
        CloseServiceHandle(schService);      
        return TRUE;     
    }     
}     
          
/*************************************    
* BOOL DeleteSampleService(LPTSTR szNameOfService)     
* 功能    删除服务    
*    
* 参数    LPTSTR szNameOfService  服务的名字    
**************************************/
BOOL DeleteSampleService(LPTSTR szNameOfService)      
{      
    schService = OpenService(      
        schSCManager,       // SCM 句柄      
        szNameOfService,    // 服务名     
        DELETE);            // 可删除     
          
    if (schService == NULL)     
    {      
        printf("OpenService failed (%d)n", GetLastError());      
        return FALSE;     
    }     
    // 删除服务     
    if (! DeleteService(schService) )      
    {     
        printf("DeleteService failed (%d)n", GetLastError());      
        return FALSE;     
    }     
    else 
        printf("DeleteService succeededn");      
    // 关闭句柄     
    CloseServiceHandle(schService);      
    return TRUE;     
}     
/*************************************    
* void main( int argc, TCHAR *argv[] )    
* 功能    演示    
*    
* 参数    未使用    
**************************************/
void main( int argc, TCHAR *argv[] )      
{     
    TCHAR szBinFilePath[MAX_PATH];     
    PTCHAR pTemp;     
    DWORD dwStopError;     
    // 构造服务可执行程序的路径     
    GetModuleFileName(NULL,szBinFilePath,MAX_PATH);     
    pTemp = szBinFilePath+lstrlen(szBinFilePath);     
    while(*--pTemp!='');     
    lstrcpy(pTemp,TEXT("SplSrv.exe"));     
          
    // 打开 SCM     
    schSCManager = OpenSCManager(      
        NULL,                    // local machine      
        NULL,                    // ServicesActive database      
        SC_MANAGER_ALL_ACCESS);  // full access rights      
          
    if (NULL == schSCManager)      
        printf("OpenSCManager failed (%d)n", GetLastError());     
          
    // 创建服务     
    CreateSampleService(schSCManager, szBinFilePath, szServiceName);     
    // 启动服务     
    StartSampleService(schSCManager,szServiceName);     
    // 发送请求控制     
    ControlSampleService(SERVICE_CONTROL_INTERROGATE);     
    ControlSampleService(SERVICE_CONTROL_CONTINUE);     
    // 停止服务     
    dwStopError = StopService( schSCManager, szServiceName,      
        TRUE, 1000);     
          
    if(ERROR_SUCCESS == dwStopError)     
    {     
        printf("Service Stopedn");      
    }      
    else
    {     
        printf("Service stoped error (%u)n",dwStopError);      
    }     
    // 删除服务     
    DeleteSampleService(szServiceName);     
    CloseServiceHandle(schSCManager);      
}



//然后我们如何控制服务呢，我们来实现启动、停止服务，向服务发送请求。
/* 头文件　*/
#include <windows.h>     
#include <tchar.h>     
#include <stdio.h>     
/* 全局变量　*/
extern SC_HANDLE schService;    // 在init.c中定义，下同     
extern SC_HANDLE schSCManager;     
extern LPTSTR szServiceName;     
          
/*************************************    
* BOOL StartSampleService(SC_HANDLE schSCManager,LPTSTR szServiceName)     
* 功能    启动服务    
*    
* 参数    SC_HANDLE schSCManager  SCM 句柄    
*       LPTSTR szServiceName    服务名    
**************************************/
BOOL StartSampleService(SC_HANDLE schSCManager,LPTSTR szServiceName)      
{      
    SC_HANDLE schService;     
    SERVICE_STATUS_PROCESS ssStatus;      
    DWORD dwOldCheckPoint;      
    DWORD dwStartTickCount;     
    DWORD dwWaitTime;     
    DWORD dwBytesNeeded;     
    // 打开服务     
    schService = OpenService(      
        schSCManager,           // SCM database      
        szServiceName,          // service name     
        SERVICE_ALL_ACCESS);      
    if (schService == NULL)      
    {      
        return 0;      
    }     
    // 启动服务     
    if (!StartService(     
        schService,  // handle to service      
        0,           // number of arguments      
        NULL) )      // no arguments      
    {     
        printf("Service start error (%u).n",GetLastError());      
        return 0;      
    }     
    else 
    {     
        printf("Service start pending.n");      
    }     
          
    // 验证状态     
    if (!QueryServiceStatusEx(      
        schService,             // handle to service      
        SC_STATUS_PROCESS_INFO, // info level     
        (LPBYTE)&ssStatus,              // address of structure     
        sizeof(SERVICE_STATUS_PROCESS), // size of structure     
        &dwBytesNeeded ) )              // if buffer too small     
    {     
        return 0;      
    }     
          
    // tick count & checkpoint.     
    dwStartTickCount = GetTickCount();     
    dwOldCheckPoint = ssStatus.dwCheckPoint;     
    // 查询状态，确定 PENDING 状态结束     
    while (ssStatus.dwCurrentState == SERVICE_START_PENDING)      
    {      
        // 等待一段时间     
        dwWaitTime = ssStatus.dwWaitHint / 10;     
        if( dwWaitTime < 1000 )     
            dwWaitTime = 1000;     
        else if ( dwWaitTime > 10000 )     
            dwWaitTime = 10000;     
        Sleep( dwWaitTime );     
        // 再次查询     
        if (!QueryServiceStatusEx(      
            schService,             // handle to service      
            SC_STATUS_PROCESS_INFO, // info level     
            (LPBYTE)&ssStatus,              // address of structure     
            sizeof(SERVICE_STATUS_PROCESS), // size of structure     
            &dwBytesNeeded ) )              // if buffer too small     
            break;      
        if ( ssStatus.dwCheckPoint > dwOldCheckPoint )     
        {     
            // 进程创建中     
            dwStartTickCount = GetTickCount();     
            dwOldCheckPoint = ssStatus.dwCheckPoint;     
        }     
        else
        {     
            if(GetTickCount()-dwStartTickCount > ssStatus.dwWaitHint)     
            {     
                // WaitHint 时间到     
                break;     
            }     
        }     
    }      
    // 关闭句柄     
    CloseServiceHandle(schService);      
    // 判断是否创建成功（状态由PENDING变为RUNNING）     
    if (ssStatus.dwCurrentState == SERVICE_RUNNING)      
    {     
        printf("StartService SUCCESS.n");      
        return 1;     
    }     
    else 
    {      
        printf("nService not started. n");     
        printf("  Current State: %dn", ssStatus.dwCurrentState);      
        printf("  Exit Code: %dn", ssStatus.dwWin32ExitCode);      
        printf("  Service Specific Exit Code: %dn",      
            ssStatus.dwServiceSpecificExitCode);      
        printf("  Check Point: %dn", ssStatus.dwCheckPoint);      
        printf("  Wait Hint: %dn", ssStatus.dwWaitHint);      
        return 0;     
    }      
}     
          
/*************************************    
* DWORD StopService( SC_HANDLE hSCM,     
LPTSTR szServiceName,     
BOOL fStopDependencies,     
DWORD dwTimeout )      
* 功能    停止服务    
*    
* 参数    SC_HANDLE hSCM          SCM 句柄    
*       LPTSTR szServiceName    服务名    
*       BOOL fStopDependencies  是否结束依赖的服务    
*       DWORD dwTimeout         超时    
**************************************/
DWORD StopService(SC_HANDLE hSCM,      
                  LPTSTR szServiceName,      
                  BOOL fStopDependencies,      
                  DWORD dwTimeout )      
{     
    SERVICE_STATUS_PROCESS ssp;     
    SERVICE_STATUS ss;     
    DWORD dwStartTime = GetTickCount();     
    DWORD dwBytesNeeded;     
    // 打开服务     
    SC_HANDLE hService = OpenService(      
        hSCM,          // SCM 句柄      
        szServiceName,          // 服务名     
        SERVICE_ALL_ACCESS);      
          
    // 查询状态，确定是否已经停止     
    if ( !QueryServiceStatusEx(      
        hService,      
        SC_STATUS_PROCESS_INFO,     
        (LPBYTE)&ssp,      
        sizeof(SERVICE_STATUS_PROCESS),     
        &dwBytesNeeded ) )     
    {     
        return GetLastError();     
    }     
    if ( ssp.dwCurrentState == SERVICE_STOPPED )      
    {     
        return ERROR_SUCCESS;     
    }     
    // 如果是 STOP_PENDING 状态，则只需等待     
    while ( ssp.dwCurrentState == SERVICE_STOP_PENDING )      
    {     
        Sleep( ssp.dwWaitHint );     
        // 循环查询，直到状态改变     
        if ( !QueryServiceStatusEx(      
            hService,      
            SC_STATUS_PROCESS_INFO,     
            (LPBYTE)&ssp,      
            sizeof(SERVICE_STATUS_PROCESS),     
            &dwBytesNeeded ) )     
        {     
            return GetLastError();     
        }     
        if ( ssp.dwCurrentState == SERVICE_STOPPED )     
        {     
            return ERROR_SUCCESS;     
        }     
        if ( GetTickCount() - dwStartTime > dwTimeout )     
        {     
            return ERROR_TIMEOUT;     
        }     
    }     
          
    // 先结束依赖服务     
    if ( fStopDependencies )      
    {     
        DWORD i;     
        DWORD dwBytesNeeded;     
        DWORD dwCount;     
          
        LPENUM_SERVICE_STATUS   lpDependencies = NULL;     
        ENUM_SERVICE_STATUS     ess;     
        SC_HANDLE               hDepService;     
          
        // 使用 0 大小的 buf,获取buf的大小     
        // 如果 EnumDependentServices 直接返回成功，说明没有依赖服务     
        if ( !EnumDependentServices( hService, SERVICE_ACTIVE,      
            lpDependencies, 0, &dwBytesNeeded, &dwCount ) )      
        {     
            if ( GetLastError() != ERROR_MORE_DATA )     
                return GetLastError(); // Unexpected error     
          
            // 分配缓冲区存储依赖服务的数据     
            lpDependencies = (LPENUM_SERVICE_STATUS) HeapAlloc(      
                GetProcessHeap(), HEAP_ZERO_MEMORY, dwBytesNeeded );     
          
            if ( !lpDependencies )     
                return GetLastError();     
          
            __try {     
                // 获得依赖服务     
                if ( !EnumDependentServices( hService, SERVICE_ACTIVE,      
                    lpDependencies, dwBytesNeeded, &dwBytesNeeded,     
                    &dwCount ) )     
                    return GetLastError();     
          
                for ( i = 0; i < dwCount; i++ )      
                {     
                    ess = *(lpDependencies + i);     
          
                    // 打开服务     
                    hDepService = OpenService( hSCM, ess.lpServiceName,      
                        SERVICE_STOP | SERVICE_QUERY_STATUS );     
                    if ( !hDepService )     
                        return GetLastError();     
          
                    __try {     
                        // 结束服务     
                        if ( !ControlService( hDepService,      
                            SERVICE_CONTROL_STOP,     
                            &ss ) )     
                            return GetLastError();     
          
                        // 等待服务结束     
                        while ( ss.dwCurrentState != SERVICE_STOPPED )      
                        {     
                            Sleep( ss.dwWaitHint );     
                            if ( !QueryServiceStatusEx(      
                                hDepService,      
                                SC_STATUS_PROCESS_INFO,     
                                (LPBYTE)&ssp,      
                                sizeof(SERVICE_STATUS_PROCESS),     
                                &dwBytesNeeded ) )     
                                return GetLastError();     
          
                            if ( ss.dwCurrentState == SERVICE_STOPPED )     
                                break;     
          
                            if ( GetTickCount() - dwStartTime > dwTimeout )     
                                return ERROR_TIMEOUT;     
                        }     
          
                    }      
                    __finally      
                    {     
                        // 关闭服务     
                        CloseServiceHandle( hDepService );     
          
                    }     
                }     
            }      
            __finally      
            {     
                // 释放内存     
                HeapFree( GetProcessHeap(), 0, lpDependencies );     
            }     
        }      
    }     
          
    // 所有的依赖服务已经结束，结束指定服务     
    if ( !ControlService( hService, SERVICE_CONTROL_STOP, &ss ) )     
        return GetLastError();     
    while ( ss.dwCurrentState != SERVICE_STOPPED )      
    {     
        Sleep( ss.dwWaitHint );     
        if ( !QueryServiceStatusEx(      
            hService,      
            SC_STATUS_PROCESS_INFO,     
            (LPBYTE)&ssp,      
            sizeof(SERVICE_STATUS_PROCESS),     
            &dwBytesNeeded ) )     
            return GetLastError();     
          
        if ( ss.dwCurrentState == SERVICE_STOPPED )     
            break;     
          
        if ( GetTickCount() - dwStartTime > dwTimeout )     
            return ERROR_TIMEOUT;     
    }     
    return ERROR_SUCCESS;     
}     
          
/*************************************    
* BOOL ControlSampleService(DWORD fdwControl)     
* 功能    向服务发送控制码    
*    
* 参数    DWORD fdwControl        控制码值    
*       SCM 句柄，服务名直接使用全局变量    
**************************************/
BOOL ControlSampleService(DWORD fdwControl)      
{      
    SERVICE_STATUS ssStatus;      
    DWORD fdwAccess;      
    DWORD dwStartTickCount, dwWaitTime;     
          
    // Access     
    switch (fdwControl)      
    {      
    case SERVICE_CONTROL_STOP:      
        fdwAccess = SERVICE_STOP;      
        break;      
    case SERVICE_CONTROL_PAUSE:      
    case SERVICE_CONTROL_CONTINUE:      
        fdwAccess = SERVICE_PAUSE_CONTINUE;      
        break;      
    case SERVICE_CONTROL_INTERROGATE:      
        fdwAccess = SERVICE_INTERROGATE;      
        break;      
    default:      
        fdwAccess = SERVICE_INTERROGATE;      
    }      
          
    // 打开服务     
    schService = OpenService(      
        schSCManager,        // SCManager 句柄      
        szServiceName,       // 服务名     
        fdwAccess);          // 存取权限     
    if (schService == NULL)      
    {     
        printf("OpenService failed (%d)n", GetLastError());      
        return FALSE;     
    }     
          
    // 发送控制码     
    if (! ControlService(      
        schService,   // 服务的句柄     
        fdwControl,   // 控制码     
        &ssStatus) )  // 状态     
    {     
        printf("ControlService failed (%d)n", GetLastError());      
        return FALSE;     
    }     
          
    // 显示状态     
    printf("nStatus of Sample_Srv: n");     
    printf("  Service Type: 0x%xn", ssStatus.dwServiceType);      
    printf("  Current State: 0x%xn", ssStatus.dwCurrentState);      
    printf("  Controls Accepted: 0x%xn",      
        ssStatus.dwControlsAccepted);      
    printf("  Exit Code: %dn", ssStatus.dwWin32ExitCode);      
    printf("  Service Specific Exit Code: %dn",      
        ssStatus.dwServiceSpecificExitCode);      
    printf("  Check Point: %dn", ssStatus.dwCheckPoint);      
    printf("  Wait Hint: %dn", ssStatus.dwWaitHint);      
          
    return TRUE;      
}
分享到：
| [转]基于Windows Socket 的网络通信中的 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Visual C++开发基于SNMP的网络管理软件01

    Visual C++开发基于SNMP的网络管理软件 高清版本，带书签，其他的几十兆的根本没法看，太模糊了。太大了分了两个压缩包。另一个看我的资源。。

    精通Windows Sockets网络开发：基于Visual C++实现

    《精通Windows Sockets网络开发：基于Visual C++实现》是一本深入探讨网络编程技术的专著，主要聚焦于使用Microsoft的Visual C++编程环境来构建网络应用。Windows Sockets（通常简称为Winsock）是微软为Windows操作...

    《精通Windows程序设计--基于Visual C++实现》中光盘源代码

    《精通Windows程序设计--基于Visual C++实现》是一本深入探讨Windows编程的书籍，通过使用Microsoft的Visual C++开发环境来讲解技术。这本书的核心在于帮助读者理解和掌握如何利用C++语言构建高效、稳定的Windows...

    <<精通Windows Sockets网络开发：基于Visual C++实现>>电子书及源码

    《精通Windows Sockets网络开发：基于Visual C++实现》是一本深入探讨网络编程技术的专业教材，专注于使用Windows Sockets API在Visual C++环境下构建网络应用。Windows Sockets，简称Winsock，是Microsoft Windows...

    精通Windows Sockets网络开发：基于Visual C++实现(附带源码).rar

    《精通Windows Sockets网络开发：基于Visual C++实现》是一本深入探讨Windows环境下使用Sockets进行网络编程的专业书籍。书中涵盖了使用Visual C++作为开发工具，实现高效、稳定的网络通信程序所需的关键技术与实践...

    Visual C++编程高手

    在IT领域，Visual C++是一种强大的编程环境，用于开发Windows平台的应用程序。它结合了C++语言的强大功能和Microsoft的Windows API，使开发者能够创建高效、高性能的应用程序。本篇文章将深入探讨Visual C++编程的...

    基于Visual C++6.0的DLL编程实现.txt

    ### 基于Visual C++6.0的DLL编程实现 #### 一、概述 动态链接库（Dynamic Link Library，简称DLL）是Windows操作系统中的一种重要组件，它允许多个应用程序共享相同的函数和数据，从而提高了资源利用率并简化了...

    Visual C++ 6.0编程技巧与实例分析

    本书《Visual C++ 6.0编程技巧与实例分析》旨在深入浅出地介绍Visual C++ 6.0的编程技巧，并通过具体的实例来分析，以便读者能更好地理解并掌握Visual C++编程的核心概念。 第一章介绍了Windows编程模式。在Windows...

    Visual C++网络高级编程(附实例代码)

    《Visual C++网络高级编程》是一本专注于使用Microsoft的Visual C++进行网络编程的专业书籍，由陈坚和陈伟合著。这本书详细介绍了如何利用Visual C++开发高效、可靠的网络应用程序，涵盖了网络通信的各个方面，包括...

    Visual C++ 开发实战

    在本书中，你将学习如何安装和配置Visual Studio，设置C++项目，并理解IDE的基本操作。 在C++语言基础部分，书中会详细介绍C++语法，包括变量、数据类型、运算符、流程控制语句（如if-else，for，while等）、函数的...

    VISUAL C++MFC编程实例

    通过阅读《Visual C++ MFC编程实例》这本书并实践源码，你可以逐步掌握如何利用MFC开发功能丰富的Windows应用程序，了解MFC的各个组件以及它们之间的协作关系。书中可能涵盖从基本的窗口创建、事件处理，到复杂的...

    Visual C++仓库管理系统 源代码

    本文将深入探讨一个基于Visual C++的仓库管理系统源代码，它利用Microsoft Foundation Class (MFC)库来实现。MFC是微软提供的一套C++类库，用于简化Windows应用程序的开发，它封装了Windows API，提供了面向对象的...

    Visual C++ MFC编程实例代码.rar

    《Visual C++ MFC编程...总结，Visual C++ MFC是Windows平台上进行C++开发的重要工具，通过深入理解和实践MFC编程实例代码，开发者能够提升在Windows环境下的软件开发能力，为构建高效、稳定的桌面应用打下坚实基础。

    Visual C++网络编程示例（Visual C++范例大全源代码）

    在IT领域，网络编程是构建分布式系统和网络应用的核心技术之一。Visual C++作为Microsoft提供的一个强大的集成开发环境，支持创建高性能的应用程序，包括网络通信软件。本篇将详细探讨"Visual C++网络编程示例"所...

    Visual+C++编程技巧精选集源代码

    《Visual C++编程技巧精选集源代码》是一个包含丰富的编程示例资源的压缩包，专为深入学习和提升VC++编程技巧而设计。这个资源集合了超过1300个实例，涵盖了各种复杂的编程概念和技术，是开发者们自我提升、实践操作...

    Visual C++环境下Windows程序开发概述 Visual C++环境下Windows程序开发概述

    它的强大之处在于能够创建基于MFC（Microsoft Foundation Classes）的Windows应用程序，这是一个C++库，提供了对Windows API的封装，使得开发者可以更高效地编写代码。 Windows程序开发的核心概念包括窗口、消息...

    精通Visual C++.NET图像处理编程(第二版)

    《精通Visual C++.NET图像处理编程(第二版)》是一本深入探讨如何使用Microsoft的C++编程语言，结合.NET框架，进行高效图像处理的技术专著。本书主要关注于使用MFC（Microsoft Foundation Classes）库来实现图像处理...

    Windows核心编程(第五版)源码

    《Windows核心编程(第五版)源码》是深入学习Windows操作系统编程的重要参考资料，结合Windows via C/C++ 5th edition这本书，提供了丰富的实践代码。这个压缩包中的源代码是作者精心设计的，旨在帮助读者理解并掌握...

    《精通Windows Sockets网络开发——基于Visual C++实现》源代码

    《精通Windows Sockets网络开发——基于Visual C++实现》是一本深入探讨网络编程技术的书籍，专注于使用C++和Microsoft的Visual C++环境。源代码提供了丰富的实例，帮助读者掌握Socket编程的核心概念和技巧，同时也...

Magicbox
Global site tag (gtag.js) - Google Analytics