wxyz2010's blog

1、介绍

Windows操作系统是应用最关的操作系统，因此动态链接库也为程序员所熟悉，即使对于普通的使用者来说，很多时候也会碰到.dll结尾的文件， 这就是动态链接库文件。Windows下的动态链接库可以通过参考头文件和.lib库文件进行编译，从而使得动态链接库隐式地被使用；也可以使用 LoadLibrary、GetProcAddress等函数来显式调用动态链接库。

2、语法、导入导出

在Windows编程中，对于要使用或被使用的函数或者变量，需要使用 __declspec 关键字来声明，以告诉编译器该变量或函数不是普通的变量或函数，而是一个动态链接库的接口属性。

如果定义一个要被其他代码使用的函数，可以写成：
__declspec( dllexport ) int add(int a, int b)；

如果在该代码中，打算使用另外一个程序中的变量，则可以写成：
__declspec( dllimport ) char *name；

动态链接库通常包含一系列供其他程序使用函数，因此 declspec( dllexport ) 语法形式最为常用。如果动态库需要其他程序中的定义的全局变量，则需要在其他程序中使用导出该变量，在动态链接库中则需要使用 extern declspec( dllexport ) 将该变量声明为外部变量以便使用。

3、链接方式

可以以下列两种方式之一链接到（或加载）DLL：

隐式链接
显式链接

隐式链接有时称为静态加载或加载时动态链接。显式链接有时称为动态加载或运行时动态链接。在隐式链接下，使用 DLL 的可执行文件链接到该 DLL 的创建者所提供的导入库（.lib 文件）。使用 DLL 的可执行文件加载时，操作系统加载此 DLL。客户端可执行文件调用 DLL 的导出函数，就好像这些函数包含在可执行文件内一样。

在显式链接下，使用 DLL 的可执行文件必须进行函数调用以显式加载和卸载该 DLL，并访问该 DLL 的导出函数。客户端可执行文件必须通过函数指针调用导出函数。可执行文件对两种链接方法可以使用同一个 DLL。另外，由于一个可执行文件可隐式链接到某个 DLL，而另一个可显式附加到此 DLL，故这些机制不是互斥的。

4、隐式链接

隐式链接动态链接库比较简单，不予详述。

5、显式链接API函数

显式链接主要涉及到3个API函数（ LoadLibrary , GetProcAddress 和 FreeLibrary ），要使用这些函数包含windows.h头文件即可。

（1）HINSTANCE LoadLibrary(LPCSTR lpLibFileName);

该函数用来加载指定动态库文件，并且返回句柄。

参数lpLibFileName为动态链接库的名称。Windows 首先搜索“已知 DLL”，如 Kernel32.dll 和 User32.dll。然后按下列顺序搜索 DLL：

1、当前进程的可执行模块所在的目录。
2、当前目录。
3、Windows 系统目录。GetSystemDirectory 函数检索此目录的路径。
4、Windows 目录。GetWindowsDirectory 函数检索此目录的路径。
5、PATH 环境变量中列出的目录。

（2）FARPROC GetProcAddress (HMODULE hModule, LPCSTR lpProcName);

函数GetProcAddress 用来获取 DLL 导出函数的地址。返回由lpProcName指定的变量或函数指针。

参数hModule为已经加载的动态库文件的句柄。

参数lpProcName为要调用的变量或函数名称。

（3）BOOL FreeLibrary(HMODULE hModule);
从内存中释放hModule所代表的动态链接库。

（4）如果发生错误，可以调用GetLastError()函数或去错误代码。

6、显示链接举例

（1）动态库文件代码：dll_demo.c

#include <stdio.h>

__declspec( dllexport ) int add(int a, int b)
{
printf("calling add\n");
return a + b;
}

该文件中的add()函数计算两个整数之和，并且返回之前打印提示字符串。函数使用 __declspec( dllexport ) 语法来说明函数add(int a, int b)要被导出。

（2）客户端事例代码：main.c

#include <stdio.h>
#include <windows.h>

int main (int argc, char *argv[])
{
int a = 10, b = 20;
int c = 0;
HINSTANCE   hInstLibrary   =   NULL;
int (*add)();

printf ("Load DLL file\n");
if ((hInstLibrary = LoadLibrary(L"dll_demo.dll")) == NULL)
{
   printf ("***LoadLibrary ERROR: %d.\n", GetLastError());
   return 1;
}
if((add = (int (*)())GetProcAddress(hInstLibrary, "add")) == NULL) {
   printf ("***GetProcAddress ERROR: %d.\n", GetLastError());
   return 1;
}

c = add(a, b);
printf("%d + %d = %d\n", a, b, c);

FreeLibrary(hInstLibrary);
return 0;
}

程序利用LoadLibrary函数加载动态链接dll_demo.dll，利用FreeLibrary关闭句柄，利用GetLastError()获取错误代码，利用GetProcAddress定位共享库中的add函数，然后调用该函数执行加法计算，并打印结果。

（3）编译与运行

编译共享库：

在VS.Net中创建一个动态链接库项目，名称为dll_demo，加入文件dll_demo.c，编译后生成dll_demo.dll文件。

编译事例程序：

在VS.Net中创建一个动态链接库项目，名称为dll_main，加入文件main.c，编译后生成dll_main.exe可以执行文件。

运行：

将 dll_demo.dll 和 dll_main.exe 放在同一个目录下，然后双击运行 dll_main.exe。

输出：

Load DLL file
calling add
10 + 20 = 30

7、调用动态链接库中的变量

也可以使用动态链接库中的变量。例如，在动态链接库中定义：

__declspec( dllexport ) int num = 100;

那么可以在事例程序中这样调用：

int *d;
d = (int *)GetProcAddress(hInstLibrary, "num");
printf("num = %d\n", *d);
  

The status of printers and print jobs are updated by the Win32 Spooler during the despool of a print job. At all other times, when that printer is not despooling and reports no state information, the printer is considered to be ready and idle.

Back to the top

MORE INFORMATION

As referred to by the Win32 API, a "printer" is comprised of the printer driver...

Back to the top

Determining the State of a Physical Printer

Back to the top

Sample Code

   BOOL GetJobs(HANDLE hPrinter,        /* Handle to the printer. */ 

                JOB_INFO_2 **ppJobInfo, /* Pointer to be filled.  */ 
                int *pcJobs,            /* Count of jobs filled.  */ 
                DWORD *pStatus)         /* Print Queue status.    */ 

   {

   DWORD               cByteNeeded,
                        nReturned,
                        cByteUsed;
    JOB_INFO_2          *pJobStorage = NULL;
    PRINTER_INFO_2       *pPrinterInfo = NULL;

   /* Get the buffer size needed. */ 
       if (!GetPrinter(hPrinter, 2, NULL, 0, &cByteNeeded))
       {
           if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
               return FALSE;
       }

       pPrinterInfo = (PRINTER_INFO_2 *)malloc(cByteNeeded);
       if (!(pPrinterInfo))
           /* Failure to allocate memory. */ 
           return FALSE;

       /* Get the printer information. */ 
       if (!GetPrinter(hPrinter,
               2,
               (LPSTR)pPrinterInfo,
               cByteNeeded,
               &cByteUsed))
       {
           /* Failure to access the printer. */ 
           free(pPrinterInfo);
           pPrinterInfo = NULL;
           return FALSE;
       }

       /* Get job storage space. */ 
       if (!EnumJobs(hPrinter,
               0,
               pPrinterInfo->cJobs,
               2,
               NULL,
               0,
               (LPDWORD)&cByteNeeded,
               (LPDWORD)&nReturned))
       {
           if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
           {
               free(pPrinterInfo);
               pPrinterInfo = NULL;
               return FALSE;
           }
       }

       pJobStorage = (JOB_INFO_2 *)malloc(cByteNeeded);
       if (!pJobStorage)
       {
           /* Failure to allocate Job storage space. */ 
           free(pPrinterInfo);
           pPrinterInfo = NULL;
           return FALSE;
       }

       ZeroMemory(pJobStorage, cByteNeeded);

       /* Get the list of jobs. */ 
       if (!EnumJobs(hPrinter,
               0,
               pPrinterInfo->cJobs,
               2,
               (LPBYTE)pJobStorage,
               cByteNeeded,
               (LPDWORD)&cByteUsed,
               (LPDWORD)&nReturned))
       {
           free(pPrinterInfo);
           free(pJobStorage);
           pJobStorage = NULL;
           pPrinterInfo = NULL;
           return FALSE;
       }

       /*
        *  Return the information.
        */ 
       *pcJobs = nReturned;
       *pStatus = pPrinterInfo->Status;
       *ppJobInfo = pJobStorage;
       free(pPrinterInfo);

       return TRUE;

   }

   BOOL IsPrinterError(HANDLE hPrinter)
   {

       JOB_INFO_2  *pJobs;
       int         cJobs,
                   i;
       DWORD       dwPrinterStatus;

       /*
        *  Get the state information for the Printer Queue and
        *  the jobs in the Printer Queue.
        */ 
       if (!GetJobs(hPrinter, &pJobs, &cJobs, &dwPrinterStatus))
			return FALSE;

       /*
        *  If the Printer reports an error, believe it.
        */ 
       if (dwPrinterStatus &
           (PRINTER_STATUS_ERROR |
           PRINTER_STATUS_PAPER_JAM |
           PRINTER_STATUS_PAPER_OUT |
           PRINTER_STATUS_PAPER_PROBLEM |
           PRINTER_STATUS_OUTPUT_BIN_FULL |
           PRINTER_STATUS_NOT_AVAILABLE |
           PRINTER_STATUS_NO_TONER |
           PRINTER_STATUS_OUT_OF_MEMORY |
           PRINTER_STATUS_OFFLINE |
           PRINTER_STATUS_DOOR_OPEN))
       {
           free( pJobs );
           return TRUE;
       }

       /*
        *  Find the Job in the Queue that is printing.
        */ 
       for (i=0; i < cJobs; i++)
       {
           if (pJobs[i].Status & JOB_STATUS_PRINTING)
           {
               /*
                *  If the job is in an error state,
                *  report an error for the printer.
                *  Code could be inserted here to
                *  attempt an interpretation of the
                *  pStatus member as well.
                */ 
               if (pJobs[i].Status &
                   (JOB_STATUS_ERROR |
                   JOB_STATUS_OFFLINE |
                   JOB_STATUS_PAPEROUT |
                   JOB_STATUS_BLOCKED_DEVQ))
               {
                   free( pJobs );
                   return TRUE;
               }
           }
       }

       /*
        *  No error condition.
        */ 
       free( pJobs );
       return FALSE;

   }
				

MORE INFORMATION

The Enumeration APIs that behave this way include: EnumForms(), EnumJobs(), Enu...

   BOOL ListJobsForPrinter( LPTSTR szPrinterName )
   {

   HANDLE         hPrinter;
   DWORD          dwNeeded, dwReturned, i;
   JOB_INFO_1     *pJobInfo;

   // You need a printer handle, open the printer
   if( ! OpenPrinter( szPrinterName, &hPrinter, NULL ) )
     return FALSE;

   // First you call EnumJobs() to find out how much memory you need
   if( ! EnumJobs( hPrinter, 0, 0xFFFFFFFF, 1, NULL, 0, &dwNeeded,
                   &dwReturned ) )
   {
     // It should have failed, but if it failed for any reason other
     // than "not enough memory", you should bail out
     if( GetLastError() != ERROR_INSUFFICIENT_BUFFER )
     {
       ClosePrinter( hPrinter );
       return FALSE;
     }
   }
   // Allocate enough memory for the JOB_INFO_1 structures plus
   // the extra data - dwNeeded from the previous call tells you
   // the total size needed
   if( (pJobInfo = (JOB_INFO_1 *)malloc( dwNeeded )) == NULL )
   {
     ClosePrinter( hPrinter );
     return FALSE;
   }
   // Call EnumJobs() again and let it fill out our structures
   if( ! EnumJobs( hPrinter, 0, 0xFFFFFFFF, 1, (LPBYTE)pJobInfo,
                   dwNeeded, &dwNeeded, &dwReturned ) )
   {
     ClosePrinter( hPrinter );
     free( pJobInfo );
     return FALSE;
   }
   // You're done with the printer handle, close it
   ClosePrinter( hPrinter );

   // dwReturned tells how many jobs there are
   // Here, you'll simply display the number of jobs found
   printf( "%d jobs\n", dwReturned );
   // It's easy to loop through the jobs and access each one
   for(i=0;i<dwReturned;i++)
   {
     // pJobInfo[i] is a JOB_INFO_1 struct for that job
     // so here you could do whatever you want for each job
     printf( "[%d] [%s]\n", pJobInfo[i].JobId, pJobInfo[i].pDocument );
   }

   // Clean up
   free( pJobInfo );
   return TRUE;
 }
				

Riddles

• Why is a manhole cover round?
• How many cars are there in the USA? (A popular variant is "How many gas stations are there in the USA?")
• How many manhole covers are there in the USA?
• You've got someone working for you for seven days and a gold bar to pay them. The gold bar is segmented into seven connected pieces. You must give them a piece of gold at the end of every day. If you are only allowed to make two breaks in the gold bar, how do you pay your worker?
• One train leaves Los Angeles at 15mph heading for New York. Another train leaves from New York at 20mph heading for Los Angeles on the same track. If a bird, flying at 25mph, leaves from Los Angeles at the same time as the train and flies back and forth between the two trains until they collide, how far will the bird have traveled?
• Imagine a disk spinning like a record player turn table. Half of the disk is black and the other is white. Assume you have an unlimited number of color sensors. How many sensors would you have to place around the disk to determine the direction the disk is spinning? Where would they be placed?
• Imagine an analog clock set to 12 o'clock. Note that the hour and minute hands overlap. How many times each day do both the hour and minute hands overlap? How would you determine the exact times of the day that this occurs?
• You have two jars, 50 red marbles and 50 blue marbles. A jar will be picked at random, and then a marble will be picked from the jar. Placing all of the marbles in the jars, how can you maximize the chances of a red marble being picked? What are the exact odds of getting a red marble using your scheme?
• Pairs of primes separated by a single number are called prime pairs. Examples are 17 and 19. Prove that the number between a prime pair is always divisible by 6 (assuming both numbers in the pair are greater than 6). Now prove that there are no 'prime triples.'
• There is a room with a door (closed) and three light bulbs. Outside the room there are three switches, connected to the bulbs. You may manipulate the switches as you wish, but once you open the door you can't change them. Identify each switch with its bulb.
• Suppose you had 8 billiard balls, and one of them was slightly heavier, but the only way to tell was by putting it on a scale against another. What's the fewest number of times you'd have to use the scale to find the heavier ball?
• Imagine you are standing in front of a mirror, facing it. Raise your left hand. Raise your right hand. Look at your reflection. When you raise your left hand your reflection raises what appears to be his right hand. But when you tilt your head up, your reflection does too, and does not appear to tilt his/her head down. Why is it that the mirror appears to reverse left and right, but not up and down?
• You have 4 jars of pills. Each pill is a certain weight, except for contaminated pills contained in one jar, where each pill is weight + 1. How could you tell which jar had the contaminated pills in just one measurement?
• The SF Chronicle has a word game where all the letters are scrambled up and you have to figure out what the word is. Imagine that a scrambled word is 5 characters long:
1. How many possible solutions are there?
2. What if we know which 5 letters are being used?
3. Develop an algorithm to solve the word.
• There are 4 women who want to cross a bridge. They all begin on the same side. You have 17 minutes to get all of them across to the other side. It is night. There is one flashlight. A maximum of two people can cross at one time. Any party who crosses, either 1 or 2 people, must have the flashlight with them. The flashlight must be walked back and forth, it cannot be thrown, etc. Each woman walks at a different speed. A pair must walk together at the rate of the slower woman's pace.

  Woman 1: 1 minute to cross
  Woman 2: 2 minutes to cross
  Woman 3: 5 minutes to cross
  Woman 4: 10 minutes to cross
  

  For example if Woman 1 and Woman 4 walk across first, 10 minutes have elapsed when they get to the other side of the bridge. If Woman 4 then returns with the flashlight, a total of 20 minutes have passed and you have failed the mission. What is the order required to get all women across in 17 minutes? Now, what's the other way?

• If you had an infinite supply of water and a 5 quart and 3 quart pail, how would you measure exactly 4 quarts?
• You have a bucket of jelly beans. Some are red, some are blue, and some green. With your eyes closed, pick out 2 of a like color. How many do you have to grab to be sure you have 2 of the same?
• If you have two buckets, one with red paint and the other with blue paint, and you take one cup from the blue bucket and poor it into the red bucket. Then you take one cup from the red bucket and poor it into the blue bucket. Which bucket has the highest ratio between red and blue? Prove it mathematically.

Algorithms

• What's the difference between a linked list and an array?
• Implement a linked list. Why did you pick the method you did?
• Implement an algorithm to sort a linked list. Why did you pick the method you did? Now do it in O(n) time.
• Describe advantages and disadvantages of the various stock sorting algorithms.
• Implement an algorithm to reverse a linked list. Now do it without recursion.
• Implement an algorithm to insert a node into a circular linked list without traversing it.
• Implement an algorithm to sort an array. Why did you pick the method you did?
• Implement an algorithm to do wild card string matching.
• Implement strstr() (or some other string library function).
• Reverse a string. Optimize for speed. Optimize for space.
• Reverse the words in a sentence, i.e. "My name is Chris" becomes "Chris is name My." Optimize for speed. Optimize for space.
• Find a substring. Optimize for speed. Optimize for space.
• Compare two strings using O(n) time with constant space.
• Suppose you have an array of 1001 integers. The integers are in random order, but you know each of the integers is between 1 and 1000 (inclusive). In addition, each number appears only once in the array, except for one number, which occurs twice. Assume that you can access each element of the array only once. Describe an algorithm to find the repeated number. If you used auxiliary storage in your algorithm, can you find an algorithm that does not require it?
• Count the number of set bits in a number. Now optimize for speed. Now optimize for size.
• Multiple by 8 without using multiplication or addition. Now do the same with 7.
• Add numbers in base n (not any of the popular ones like 10, 16, 8 or 2 -- I hear that Charles Simonyi, the inventor of Hungarian Notation, favors -2 when asking this question).
• Write routines to read and write a bounded buffer.
• Write routines to manage a heap using an existing array.
• Implement an algorithm to take an array and return one with only unique elements in it.
• Implement an algorithm that takes two strings as input, and returns the intersection of the two, with each letter represented at most once. Now speed it up. Now test it.
• Implement an algorithm to print out all files below a given root node.
• Given that you are receiving samples from an instrument at a constant rate, and you have constant storage space, how would you design a storage algorithm that would allow me to get a representative readout of data, no matter when I looked at it? In other words, representative of the behavior of the system to date.
• How would you find a cycle in a linked list?
• Give me an algorithm to shuffle a deck of cards, given that the cards are stored in an array of ints.
• The following asm block performs a common math function, what is it?

  cwd xor ax, dx
  sub ax, dx

• Imagine this scenario:
  I/O completion ports are communictaions ports which take handles to files, sockets, or any other I/O. When a Read or Write is submitted to them, they cache the data (if necessary), and attempt to take the request to completion. Upon error or completion, they call a user-supplied function to let the users application know that that particular request has completed. They work asynchronously, and can process an unlimited number of simultaneous requests.
  Design the implementation and thread models for I/O completion ports. Remember to take into account multi-processor machines.
• Write a function that takes in a string parameter and checks to see whether or not it is an integer, and if it is then return the integer value.
• Write a function to print all of the permutations of a string.
• Implement malloc.
• Write a function to print the Fibonacci numbers.
• Write a function to copy two strings, A and B. The last few bytes of string A overlap the first few bytes of string B.
• How would you write qsort?
• How would you print out the data in a binary tree, level by level, starting at the top?

Applications

• How can computer technology be integrated in an elevator system for a hundred story office building? How do you optimize for availability? How would variation of traffic over a typical work week or floor or time of day affect this?
• How would you implement copy-protection on a control which can be embedded in a document and duplicated readily via the Internet?
• Define a user interface for indenting selected text in a Word document. Consider selections ranging from a single sentence up through selections of several pages. Consider selections not currently visible or only partially visible. What are the states of the new UI controls? How will the user know what the controls are for and when to use them?
• How would you redesign an ATM?
• Suppose we wanted to run a microwave oven from the computer. What kind of software would you write to do this?
• What is the difference between an Ethernet Address and an IP address?
• How would you design a coffee-machine for an automobile.
• If you could add any feature to Microsoft Word, what would it be?
• How would you go about building a keyboard for 1-handed users?
• How would you build an alarm clock for deaf people?

Thinkers

• How are M&Ms made?
• If you had a clock with lots of moving mechanical parts, you took it apart piece by piece without keeping track of the method of how it was disassembled, then you put it back together and discovered that 3 important parts were not included; how would you go about reassembling the clock?
• If you had to learn a new computer language, how would you go about doing it?
• You have been assigned to design Bill Gates bathroom. Naturally, cost is not a consideration. You may not speak to Bill.
• What was the hardest question asked of you so far today?
• If MS told you we were willing to invest $5 million in a start up of your choice, what business would you start? Why?
• If you could gather all of the computer manufacturers in the world together into one room and then tell them one thing that they would be compelled to do, what would it be?
• Explain a scenario for testing a salt shaker.
• If you are going to receive an award in 5 years, what is it for and who is the audience?
• How would you explain how to use Microsoft Excel to your grandma?
• Why is it that when you turn on the hot water in any hotel, for example, the hot water comes pouring out almost instantaneously?
• Why do you want to work at Microsoft?
• Suppose you go home, enter your house/apartment, hit the light switch, and nothing happens - no light floods the room. What exactly, in order, are the steps you would take in determining what the problem was?
• Interviewer hands you a black pen and says nothing but "This pen is red."