heapalloc（C++中用哪个函数可以获得当前网卡的物理地址）

本文目录

• C++中用哪个函数可以获得当前网卡的物理地址
• HeapAlloc啥意思啊

C++中用哪个函数可以获得当前网卡的物理地址

//如果是Windows
//The GetAdaptersAddresses function retrieves the addresses
//associated with the adapters on the local computer.
ULONG WINAPI GetAdaptersAddresses(
  _In_    ULONG                 Family,
  _In_    ULONG                 Flags,
  _In_    PVOID                 Reserved,
  _Inout_ PIP_ADAPTER_ADDRESSES AdapterAddresses,
  _Inout_ PULONG                SizePointer
);
/*
Family [in]
The address family of the addresses to retrieve.这个参数必须是以下值之一.
AF_UNSPEC 返回开启IPv4和IPv6的适配器的IPv4和IPv6地址.
AF_INET 返回开启IPv4的适配器的IPv4地址.
AF_INET6 只返回开启IPv6的适配器的IPv6地址.
------------------------------------------------------------------------------
Flags [in]
需要得到的地址类型.可能值在头文件Iptypes.h中定义.注意到Iptypes.h自动包含在Iphlpapi.h里面，应该永远不要直接使用它.这个参数可以是以下值的组合.如果此参数是0,那么单播、任播、多播IP地址都将会返回.
------------------------------------------------------------------------------
Reserved [in]
这个参数现在未使用,但是是保留为了将来系统使用,在这个调用应该给予NULL.
------------------------------------------------------------------------------
AdapterAddresses [in, out]
一个指针指向缓冲区，函数成功返回时，用来保存IP_ADAPTER_ADDRESSES结构的链表.
------------------------------------------------------------------------------
SizePointer [in, out]
一个指针，指向“表明AdapterAddress指向的缓冲区大小的变量“.
--------------------------------------------------------------------------
返回值
如果函数成功,返回值为ERROR_SUCCESS (defined to the same value as NO_ERROR).
如果函数失败,返回值是以下错误值之一.
*/
//C++示例代码
//来源于MSDN
#include 《winsock2.h》
#include 《iphlpapi.h》
#include 《stdio.h》
#include 《stdlib.h》

// Link with Iphlpapi.lib
#pragma comment(lib, “IPHLPAPI.lib“)

#define WORKING_BUFFER_SIZE 15000
#define MAX_TRIES 3

#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))
#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))

/* Note: could also use malloc() and free() */

int __cdecl main(int argc, char **argv)
{

    /* Declare and initialize variables */

    DWORD dwSize = 0;
    DWORD dwRetVal = 0;

    unsigned int i = 0;

    // Set the flags to pass to GetAdaptersAddresses
    ULONG flags = GAA_FLAG_INCLUDE_PREFIX;

    // default to unspecified address family (both)
    ULONG family = AF_UNSPEC;

    LPVOID lpMsgBuf = NULL;

    PIP_ADAPTER_ADDRESSES pAddresses = NULL;
    ULONG outBufLen = 0;
    ULONG Iterations = 0;

    PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
    PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
    PIP_ADAPTER_ANYCAST_ADDRESS pAnycast = NULL;
    PIP_ADAPTER_MULTICAST_ADDRESS pMulticast = NULL;
    IP_ADAPTER_DNS_SERVER_ADDRESS *pDnServer = NULL;
    IP_ADAPTER_PREFIX *pPrefix = NULL;

    if (argc != 2) {
        printf(“ Usage: getadapteraddresses family\n“);
        printf(“        getadapteraddresses 4 (for IPv4)\n“);
        printf(“        getadapteraddresses 6 (for IPv6)\n“);
        printf(“        getadapteraddresses A (for both IPv4 and IPv6)\n“);
        exit(1);
    }

    if (atoi(argv) == 4)
        family = AF_INET;
    else if (atoi(argv) == 6)
        family = AF_INET6;

    printf(“Calling GetAdaptersAddresses function with family = “);
    if (family == AF_INET)
        printf(“AF_INET\n“);
    if (family == AF_INET6)
        printf(“AF_INET6\n“);
    if (family == AF_UNSPEC)
        printf(“AF_UNSPEC\n\n“);

    // Allocate a 15 KB buffer to start with.
    outBufLen = WORKING_BUFFER_SIZE;

    do {

        pAddresses = (IP_ADAPTER_ADDRESSES *) MALLOC(outBufLen);
        if (pAddresses == NULL) {
            printf
                (“Memory allocation failed for IP_ADAPTER_ADDRESSES struct\n“);
            exit(1);
        }

        dwRetVal =
            GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);

        if (dwRetVal == ERROR_BUFFER_OVERFLOW) {
            FREE(pAddresses);
            pAddresses = NULL;
        } else {
            break;
        }

        Iterations++;

    } while ((dwRetVal == ERROR_BUFFER_OVERFLOW) && (Iterations 《 MAX_TRIES));

    if (dwRetVal == NO_ERROR) {
        // If successful, output some information from the data we received
        pCurrAddresses = pAddresses;
        while (pCurrAddresses) {
            printf(“\tLength of the IP_ADAPTER_ADDRESS struct: %ld\n“,
                   pCurrAddresses-》Length);
            printf(“\tIfIndex (IPv4 interface): %u\n“, pCurrAddresses-》IfIndex);
            printf(“\tAdapter name: %s\n“, pCurrAddresses-》AdapterName);

            pUnicast = pCurrAddresses-》FirstUnicastAddress;
            if (pUnicast != NULL) {
                for (i = 0; pUnicast != NULL; i++)
                    pUnicast = pUnicast-》Next;
                printf(“\tNumber of Unicast Addresses: %d\n“, i);
            } else
                printf(“\tNo Unicast Addresses\n“);

            pAnycast = pCurrAddresses-》FirstAnycastAddress;
            if (pAnycast) {
                for (i = 0; pAnycast != NULL; i++)
                    pAnycast = pAnycast-》Next;
                printf(“\tNumber of Anycast Addresses: %d\n“, i);
            } else
                printf(“\tNo Anycast Addresses\n“);

            pMulticast = pCurrAddresses-》FirstMulticastAddress;
            if (pMulticast) {
                for (i = 0; pMulticast != NULL; i++)
                    pMulticast = pMulticast-》Next;
                printf(“\tNumber of Multicast Addresses: %d\n“, i);
            } else
                printf(“\tNo Multicast Addresses\n“);

            pDnServer = pCurrAddresses-》FirstDnsServerAddress;
            if (pDnServer) {
                for (i = 0; pDnServer != NULL; i++)
                    pDnServer = pDnServer-》Next;
                printf(“\tNumber of DNS Server Addresses: %d\n“, i);
            } else
                printf(“\tNo DNS Server Addresses\n“);

            printf(“\tDNS Suffix: %wS\n“, pCurrAddresses-》DnsSuffix);
            printf(“\tDescription: %wS\n“, pCurrAddresses-》Description);
            printf(“\tFriendly name: %wS\n“, pCurrAddresses-》FriendlyName);

            if (pCurrAddresses-》PhysicalAddressLength != 0) {
                printf(“\tPhysical address: “);
                for (i = 0; i 《 (int) pCurrAddresses-》PhysicalAddressLength;
                     i++) {
                    if (i == (pCurrAddresses-》PhysicalAddressLength - 1))
                        printf(“%.2X\n“,
                               (int) pCurrAddresses-》PhysicalAddress[i]);
                    else
                        printf(“%.2X-“,
                               (int) pCurrAddresses-》PhysicalAddress[i]);
                }
            }
            printf(“\tFlags: %ld\n“, pCurrAddresses-》Flags);
            printf(“\tMtu: %lu\n“, pCurrAddresses-》Mtu);
            printf(“\tIfType: %ld\n“, pCurrAddresses-》IfType);
            printf(“\tOperStatus: %ld\n“, pCurrAddresses-》OperStatus);
            printf(“\tIpv6IfIndex (IPv6 interface): %u\n“,
                   pCurrAddresses-》Ipv6IfIndex);
            printf(“\tZoneIndices (hex): “);
            for (i = 0; i 《 16; i++)
                printf(“%lx “, pCurrAddresses-》ZoneIndices[i]);
            printf(“\n“);

            printf(“\tTransmit link speed: %I64u\n“, pCurrAddresses-》TransmitLinkSpeed);
            printf(“\tReceive link speed: %I64u\n“, pCurrAddresses-》ReceiveLinkSpeed);

            pPrefix = pCurrAddresses-》FirstPrefix;
            if (pPrefix) {
                for (i = 0; pPrefix != NULL; i++)
                    pPrefix = pPrefix-》Next;
                printf(“\tNumber of IP Adapter Prefix entries: %d\n“, i);
            } else
                printf(“\tNumber of IP Adapter Prefix entries: 0\n“);

            printf(“\n“);

            pCurrAddresses = pCurrAddresses-》Next;
        }
    } else {
        printf(“Call to GetAdaptersAddresses failed with error: %d\n“,
               dwRetVal);
        if (dwRetVal == ERROR_NO_DATA)
            printf(“\tNo addresses were found for the requested parameters\n“);
        else {

            if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                    FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 
                    NULL, dwRetVal, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),   
                    // Default language
                    (LPTSTR) & lpMsgBuf, 0, NULL)) {
                printf(“\tError: %s“, lpMsgBuf);
                LocalFree(lpMsgBuf);
                if (pAddresses)
                    FREE(pAddresses);
                exit(1);
            }
        }
    }

    if (pAddresses) {
        FREE(pAddresses);
    }

    return 0;
}

HeapAlloc啥意思啊

HeapAlloc是内存分配函数，详细权威的文档参考MSDN。

//分配了一块内存，大小是sizeof(Student) + 1024，并且内存的地址保存在变量stu里
HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,sizeof(Student) + 1024);

这块内存地址被强制转化为类型(Student*)，编译器在得到这个信息之后，会使用(Student)类型来解析你的代码对这块内存的访问。目前来看，这是一块放满了0的内存，里面没有任何对象和数据，就是一堆0。为什么，因为你使用了HEAP_ZERO_MEMORY标志。

更多说明，建议参考MSDN。