VC 获得系统时间、程序运行时间、…

1.使用CTime类
CString
str;

//获取系统时间

CTime tm;

tm=CTime::GetCurrentTime();

str=tm.Format("现在时间是%Y年%m月%d日
%X");

MessageBox(str,NULL,MB_OK);

2:
得到系统时间日期(使用GetLocalTime)

SYSTEMTIME st;

CString strDate,strTime;

GetLocalTime(&st);

strDate.Format("M----",st.wYear,st.wMonth,st.wDay);

strTime.Format("-:-:-",st.wHour,st.wMinute,st.wSecond);

3.使用GetTickCount

//获取程序运行时间

long t1=GetTickCount();//程序段开始前取得系统运行时间(ms)

Sleep(500);

long
t2=GetTickCount();();//程序段结束后取得系统运行时间(ms)

str.Format("time:%dms",t2-t1);//前后之差即
程序运行时间

AfxMessageBox(str);

//获取系统运行时间

long t=GetTickCount();

CString str,str1;

str1.Format("系统已运行 %d时",t/3600000);

str=str1;

t%=3600000;

str1.Format("%d分",t/60000);

str+=str1;

t%=60000;

str1.Format("%d秒",t/1000);

str+=str1;

AfxMessageBox(str);

*******************************************************************************

4、获得本地计算机名和IP地址

CString
m_IP;//IP地址临时变量

//获得本地计算机名

char PCnameBuffer[128];

if(0==gethostname(PCnameBuffer,128))

{

m_PCname=PCnameBuffer;

//获得本地IP地址

struct hostent* pHost;

int i;

pHost=gethostbyname(PCnameBuffer);//pHost返回的是指向主机的列表

for
(i=0;pHost!=NULL&&pHost->h_addr_list[i]!=NULL;i++)

{

LPCSTR psz =
inet_ntoa(*(struct in_addr
*)pHost->h_addr_list[i]);//得到指向ip的psz变量

m_IP +=
psz;

}

m_LocalIP=m_IP;

}

else

{

AfxMessageBox("获取本地IP失败！");

return;

}

4.获取网卡MAC

//方法一

CString
PrintMACaddress(unsigned char
MACData[])

{

CString mac;

char MAC[40]={0};

sprintf(MAC,"XXXXXX", MACData[0], MACData[1], MACData[2],
MACData[3], MACData[4], MACData[5]);

mac=MAC;

return mac;

}

CString GetMACaddress(void)

{

IP_ADAPTER_INFO AdapterInfo[16]; // Allocate information for up
to 16 NICs

DWORD dwBufLen = sizeof(AdapterInfo); // Save the memory size of
buffer

DWORD dwStatus = GetAdaptersInfo( // Call GetAdapterInfo

AdapterInfo, // [out] buffer to receive data

&dwBufLen); // [in] size of receive data
buffer

assert(dwStatus == ERROR_SUCCESS); // Verify return value is
valid, no buffer overflow

PIP_ADAPTER_INFO pAdapterInfo = AdapterInfo;// Contains pointer
to current adapter info

//do {

//int i=0;

//PrintMACaddress(pAdapterInfo->Address);// Print
MAC address

//pAdapterInfo = pAdapterInfo->Next; // Progress
through linked list

//i++;

//}

//while(pAdapterInfo); // Terminate if last adapter

if(pAdapterInfo)

return
PrintMACaddress(pAdapterInfo->Address);

else

return _T("XXXXXXXXXX");

}

//方法二:在xp下有效,win7下无效

CString GetNetMac(void)

{

CString f_search="Physical Address";

BOOL f_result;

SECURITY_ATTRIBUTES f_sa;

HANDLE f_hReadPipe,f_hWritePipe;

CString f_mac="";

f_sa.nLength=sizeof(SECURITY_ATTRIBUTES);

f_sa.lpSecurityDescriptor=NULL;

f_sa.bInheritHandle=TRUE;

f_result=CreatePipe(&f_hReadPipe,&f_hWritePipe,&f_sa,0);

if(!f_result)

return f_mac;

STARTUPINFO f_si;

PROCESS_INFORMATION f_pi;

memset(&f_si,0,sizeof(STARTUPINFO));

f_si.cb=sizeof(STARTUPINFO);

GetStartupInfo(&f_si);

f_si.hStdError=f_hWritePipe;

f_si.hStdOutput=f_hWritePipe;

f_si.wShowWindow=SW_HIDE;

f_si.dwFlags=STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;

f_result=CreateProcess(NULL,"ipconfig
/all",NULL,NULL,true,0,NULL,NULL,&f_si,&f_pi);

char f_buffer[1000];

if(f_result)

{

WaitForSingleObject(f_pi.hProcess,INFINITE);

unsigned long f_count;

CloseHandle(f_hWritePipe);

memset(f_buffer,0x00,sizeof(f_buffer));

f_result=ReadFile(f_hReadPipe,f_buffer,1000,&f_count,0);

if(f_result)

{

f_mac=f_buffer;

long f_ipos=f_mac.Find(f_search);

if(f_ipos<0)

{

f_mac="";

}

else

{

f_mac=f_mac.Mid(f_ipos+1,100);

f_ipos=f_mac.Find(":");

f_mac=f_mac.Mid(f_ipos+2,17);

}

}

}

CloseHandle(f_pi.hProcess);

CloseHandle(f_pi.hThread);

CloseHandle(f_hReadPipe);

f_mac.Remove('-');

return f_mac;

}

5.获取网卡流量

BOOL CTSysWatch::GetNetAdapterFlux(LPNETADAPTER_FLUX
pAdapterFlux, int nIndex )

{

// Declare and initialize variables

DWORD dwRetVal = 0;

// Make an initial call to GetIfTable to get the

// necessary size into the dwSize variable

if(m_ifTable == NULL)

{

if (GetIfTable(m_ifTable, &m_dwTableSize, 0) ==
ERROR_INSUFFICIENT_BUFFER)

{

m_ifTable = (MIB_IFTABLE *) malloc (m_dwTableSize);

}

}

// Make a second call to GetIfTable to get
the

// actual data we want

if ((dwRetVal = GetIfTable(m_ifTable,
&m_dwTableSize, 0)) !=
NO_ERROR)

{

return FALSE;

}

int nPos = 0;

for(int i = 0; i <
(int)m_ifTable->dwNumEntries; i++)

{

if(m_ifTable->table[i].dwIndex ==
(DWORD)nIndex)

{

nPos = i;

break;

}

}

if(nPos == (int)m_ifTable->dwNumEntries)

return FALSE;

if(m_parrAdapterTable == NULL)

{

m_parrAdapterTable = new
ADAPTER_TABLE[m_ifTable->dwNumEntries];

memset(m_parrAdapterTable,0,m_ifTable->dwNumEntries
* sizeof(ADAPTER_TABLE));

m_parrAdapterTable[nPos].dwOldInOctets =
m_ifTable->table[nPos].dwInOctets;

m_parrAdapterTable[nPos].dwOldOutOctets =
m_ifTable->table[nPos].dwOutOctets;

return TRUE;

}

//in

pAdapterFlux->fInCurrentFlux =
(float)((m_ifTable->table[nPos].dwInOctets -
m_parrAdapterTable[nPos].dwOldInOctets) * 8.0/1000.0);

m_parrAdapterTable[nPos].dwOldInOctets =
m_ifTable->table[nPos].dwInOctets;

if(pAdapterFlux->fInCurrentFlux >
m_parrAdapterTable[nPos].fInMaxFlux)

m_parrAdapterTable[nPos].fInMaxFlux =
pAdapterFlux->fInCurrentFlux;

pAdapterFlux->fInMaxFlux =
m_parrAdapterTable[nPos].fInMaxFlux;

m_parrAdapterTable[nPos].fInAverageFlux =
(float)(m_parrAdapterTable[nPos].fInAverageFlux +
(pAdapterFlux->fInCurrentFlux -
m_parrAdapterTable[nPos].fInAverageFlux) /
(m_parrAdapterTable[nPos].dwTimes + 1.0));

pAdapterFlux->fInAverageFlux =
m_parrAdapterTable[nPos].fInAverageFlux;

//out

pAdapterFlux->fOutCurrentFlux =
(float)((m_ifTable->table[nPos].dwOutOctets -
m_parrAdapterTable[nPos].dwOldOutOctets) * 8.0/1000.0);

m_parrAdapterTable[nPos].dwOldOutOctets =
m_ifTable->table[nPos].dwOutOctets;

if(pAdapterFlux->fOutCurrentFlux >
m_parrAdapterTable[nPos].fOutMaxFlux)

m_parrAdapterTable[nPos].fOutMaxFlux =
pAdapterFlux->fOutCurrentFlux;

pAdapterFlux->fOutMaxFlux =
m_parrAdapterTable[nPos].fOutMaxFlux;

m_parrAdapterTable[nPos].fOutAverageFlux =
(float)(m_parrAdapterTable[nPos].fOutAverageFlux +
(pAdapterFlux->fOutCurrentFlux -
m_parrAdapterTable[nPos].fOutAverageFlux) /
(m_parrAdapterTable[nPos].dwTimes + 1.0));

pAdapterFlux->fOutAverageFlux =
m_parrAdapterTable[nPos].fOutAverageFlux;

m_parrAdapterTable[nPos].dwTimes++;

return TRUE;

}

//return 0 success

//return 1 ERROR_INSUFFICIENT_BUFFER

//return -1 failed

BOOL CTSysWatch::GetNetAdapterInfo(LPNETINTERFACE_INFO
pIfInfo,PDWORD pdwCount)

{

// Declare and initialize variables

DWORD dwRetVal = 0;

// Make an initial call to GetIfTable to get the

// necessary size into the dwSize variable

if(m_ifTable == NULL)

{

if (GetIfTable(m_ifTable, &m_dwTableSize, 0) ==
ERROR_INSUFFICIENT_BUFFER)

{

m_ifTable = (MIB_IFTABLE *) malloc (m_dwTableSize);

}

}

// Make a second call to GetIfTable to get
the

// actual data we want

if ((dwRetVal = GetIfTable(m_ifTable,
&m_dwTableSize, 0)) !=
NO_ERROR)

{

return -1;

}

if(*pdwCount <
m_ifTable->dwNumEntries)

{

*pdwCount = m_ifTable->dwNumEntries;

return 1;

}

for(int i = 0; i <
(int)m_ifTable->dwNumEntries; i++)

{

pIfInfo[i].dwIndex =
m_ifTable->table[i].dwIndex;

pIfInfo[i].dwType =
m_ifTable->table[i].dwType;

memcpy(pIfInfo[i].bDescr,m_ifTable->table[i].bDescr,MAXLEN_IFDESCR);

}

return 0;

}

调用:

char szTmp[25] = {0};

NETADAPTER_FLUX AdapterFlux = {0};

GetNetAdapterFlux(&AdapterFlux);

memset(szTmp,0x00,25);

sprintf(szTmp,"%.2fk/%.2fk",AdapterFlux.fInCurrentFlux,AdapterFlux.fOutCurrentFlux);