The C Programming Language 笔记(2)

Chapter 5: Pointers and Arrays

 

 

    Pointers are much used in C, partly because they are sometimes the only way to express a computation, and partly they usually lead to more compact and efficient code than can be obtained in other ways.
    The unary operator & gives the address of an object
    char *p = &ch; 
    THe & cann't be applied to expressions, constants, or register variables.
    Pointers can deference anything, but themselves.
   
    notice:unary operator like * and ++ associate right to left. so:
    ++*p and (*p)++ and *p += 1 are equal.
   
Pointers and Function arguments:
    Since C passed agruments to functions by value, there is no direct way for the called function to alter a variable in the calling function. So, it isn't enough to write
        void swap(int x, int y) { x += y; y = x - y; x = x - y; } 
    
    The way to obtain the desired effect is:
        swap(&a, &b); 
    and change the formal of function's arguments to
        void swap(int *px, int *py); 
    
Pointers and Arrays:
    int a[10], i; /* define an array */ int *pi; /* define a pointer to int */ pi = a; /* same effect with: pi = &a[0] */ *(a+i) = 0; /* a+i is the address of a[i], sometimes i can be a negative */ 
    
    There is one difference bewteen an array name and a pointer name that must be kept in mind. A poiner is a variable, so pi = a and pi++ are legal. But an array name is not a variable; constructions like a = pi and a++ are illegal.
   
Address arithmetic:
    The valid pointer operations are assignment of pointers of the same type, adding or subtracting a pointer and an integer, subtracting or comparing two pointers to members of the same array, and assigning or comparing to zero. All other pointer arithmetic is illegal. It isn't legal to add two pointers, or to multiply or divide or shift or mask them, or to add float or doule to them, or even, except for void *, to assign a pointer to one type to a pointer of another type without a cast.
   
Character pointers and Functions :
    C doesn't provide any operators for processing an entire string of characters as a unit.
   
    notice:    char *pMessage = "Hello world"; /* This isn't a string copy, only pointer is involved */ char *aMessage[] = "Hello world"; /* The string is saved at array */ 
   
Pointers to Functions:
    In C, a function itself isn't a variable, but it's possible to define pointers to functions, which can be assigned, placed in array, passed to functions, returned by functions, and so on.
     notice:
    * is a prefix operator and it has lower precedence than (), soparentheses are necessary to force the proper association.    int *fun(void *, void*); /* a function that have two void * arguments and returns a pointer to an int */ int (*fp)(void *, void*); /* a pointer to a function that have two void * arguments and returns an int */ (*fp)(p1, p2); /* *fp is the function ,the statement is the call to the function, fp */ char **a; /* a: pointer to pointer to char */ int (*a)[13]; /* a: pointer to array[13] of int */ int *a[13]; /* a: array[13] of pointer to int */ void *f(); /* f: function returning an pointer to void */ void (*f)(); /* f: pointer to function returning void */ char (*(*f())[])(); /* f: function returning pointer to array[] of pointer to function returning char */ char (*(*f[3])())[5]; /* f: array[3] of pointer to fcnction returning pointer to array[5] of char */ 
   
         
   
Chapter 6: Structures

 

    A structure is a collection of one or more variables, possibly of different types, grouped under a single name for converient handling.
    The main change made by the ANSI standard is to define structure assignment-structure may be copied and assigned to, passed to functions, and returned by functions. Automatic structures and arrays may now are initialized.
    struct point p1; struct point p2 = {100,200}; /* structures can be initialized */ struct point makepoint(int x, int y) /* structures can be returned by functions */ { blablabla... } Arrays of sturctures: struct point { int x; int y; }arr_point[] = { 1,2, 1,3, 1,4, 1,5, 2,1, 2,2, 2,3 }; 
    
    A sizeof can't be used in a #if line, because the preprocessor doesn't parse type names. But the expression in the #define is not evaluated by the preprocessor, so the code here is legal.
    #define N_ARRAY (sizeof(arr_point) / sizeof(struct point)) #define N_ARRAY (sizeof(arr_point) / sizeof(arr_point[0])) 
   
Unions:
    A union is a variable that may hold (at different times) objects of different types and sizes, with the compiler keeping track of size and alignment requirements.
    In effect, a union is a structure in which all members have offset zero from the base, the structure is big enought to hold the "widest" member, and the alignment is appropriate for all of the types in the union. The same operations are premitted on unions as on structures: assignment to or copying as a unit, taking the address, and accessing a member.
    A union may only be initialized with a value of the type of its first number.
   
Bit-fields:
    struct { unsigned int iBitfield1 : 1; unsigned int iBitfield2 : 5; unsigned int iBitfield3 : 1; }flag; 
    
    Almost everything about fields is implementation-dependent.
    They are not arrays, and they don't have address, so the & operator can't be applied to them.