home *** CD-ROM | disk | FTP | other *** search
/ C++ for Dummies (3rd Edition) / C_FD.iso / WORKOUT / PART1.TXT next >
Text File  |  1996-09-06  |  3KB  |  91 lines
  1. 25-Minute Workout
  2. Part I Answers
  3. Hey! Go back and try to answer the questions on your own first.
  4. 1
  5.     a.    int array[10]
  6.     b.    int *pInt
  7.     c.    int *arrayPtrs[10]
  8.         Note that [] has a higher precedence than *, which is what keeps this from being a 
  9. pointer to an array of ten integers.
  10.     d.    int *fn(void)
  11.     e.    void (*pFn)(int*)
  12.         The parentheses around pFn are necessary to keep this from being a function that 
  13. returns a pointer to an integer (like 2d).
  14. 2
  15. I gave you a big hint on this one (actually two hints). Without a prototype, C passes both arguments as 
  16. integers ù what does it know? The first argument is fine, but fn expects a float for the second argument. 
  17. The integer provided is interpreted as garbage.
  18. The solution is to add a prototype:
  19. int fn(int, float);
  20.  
  21. void anotherFn()
  22. {
  23.    int x;
  24.    x = fn(1, 2);
  25. }
  26. Some of you might have said, ôAh well, letÆs just change the call.ö
  27. void anotherFn()
  28. {
  29.    int x;
  30.    x = fn(1, 2.0);
  31. }
  32. This doesnÆt work either. To maintain compatibility with the older K&R C, a float is passed as a double in 
  33. the absence of a prototype. Thus, the second argument ends up at fn() as a double and not a float. As 
  34. Homer Simpson would say, ôDOOO.ö
  35. 3
  36. The answer is ômaybe nothing,ö depending on your compiler. The potential problem is in the printf() 
  37. statement:
  38. printf(ôarray[%2d] = %d,  array[%2d] = %d\nö,
  39.        i, pArray[i++], i, pArray[i++]);
  40. Notice that this expression contains many subexpressions that have mutual side effects, namely i++. The 
  41. programmer of this statement is assuming that the subexpressions are evaluated from left to right. They 
  42. might well be, but ANSI C doesnÆt guarantee it. (Under Borland and Turbo C++, for example, 
  43. subexpressions passed to a function are evaluated from right to left.)
  44. Adding parentheses doesnÆt help. The only way to solve this problem is to break up the expression into 
  45. several independent expressions, as follows:
  46. printf(ôarray[%2d] = %d,    ô, i, pArray[i]);
  47. i++;
  48.  
  49. printf(ôarray[%2d] = %d\nö   , i, pArray[i]);
  50. i++;
  51. 4
  52. The following function does the trick:
  53. #include <stdio.h>
  54.  
  55. void fn(int *pX, int *pY)
  56. {
  57.    int localX, localY;
  58.  
  59.    /*first read value into local variables*/
  60.    printf(ôEnter x & y:ö);
  61.    scanf(ô%d%dö, &localX, &localY);
  62.  
  63.    /*now copy into callerÆs arguments*/
  64.    *pX = localX;
  65.    *pY = localY;
  66. }
  67.  
  68. int main()
  69. {
  70.    int x, y;
  71.  
  72.    fn(&x, &y);      /*have to pass the address here*/
  73.    return 0;
  74. }
  75. This function first reads the data values into local variables, and then copies the variables to the callerÆs x 
  76. and y variables.
  77. Notice that the local variables are not necessary. The following works just fine:
  78. #include <stdio.h>
  79.  
  80. void fn(int *pX, int *pY)
  81. {
  82.    printf(ôEnter x & y:ö);
  83.    scanf(ô%d%dö, pX, pY);
  84. }
  85. 5
  86. The function sizeOfMyStruct() will always return a 1, irrespective of the actual size of a MyStruct structure. 
  87. Remember that pointer addition and subtraction are always defined in terms of the sizes of the objects 
  88. pointed to. Therefore, &x[i]û&x[j] is equal to iûj no matter what the type of x. Use the sizeof keyword to 
  89. return the size of a structure or an object.
  90.  
  91.