嵌入式 C 语言的八大难点揭秘

void f1(char *explanation)
{
  char p1;
  p1 = malloc(100);
  sprintf(p1,The f1 error occurred because of '%s'.",explanation);
  local_log(p1);
}

int getkey(char *filename)
{
    FILE *fp;
    int key;
    fp = fopen(filename, r");
    fscanf(fp, %d", &key);
    return key;
}

void f2(int datum)
{
   int *p2;
   * Uh-oh!  No one has initialized p2. */
   *p2 = datum;
   ...
}

* Allocate once, free twice. */
void f3()
{
    char *p;
    p = malloc(10);
     ...
    free(p);
     ...
    free(p);
}

* Allocate zero times, free once. */
void f4()
{
   char *p;
   * Note that p remains uninitialized here. */
   free(p);
}

void f8()
{
   struct x *xp;
   xp = (struct x *) malloc(sizeof (struct x));
   xp.q = 13;
   ...
   free(xp);
   ...
* Problem!  There's no guarantee that
  the memory block to which xp points
  hasn't been overwritten. */
  return xp.q;
}

********
* ...
*
* Note that any function invoking protected_file_read()
* assumes responsibility eventually to fclose() its
* return value, UNLESS that value is NULL.
*
********
FILE *protected_file_read(char *filename)
{
    FILE *fp;

    fp = fopen(filename, r");
    if (fp) {
...
    } else {
...
    }
    return fp;
}

        *******
* ...
*
* Note that the return value of get_message points to a
* fixed memory location.  Do NOT free() it; remember to
* make a copy if it must be retained ...
*
********
char *get_message()
{
    static char this_buffer[400];

            ...
    (void) sprintf(this_buffer, ...);
    return this_buffer;
        }


        ********
* ...
* While this function uses heap memory, and so 
* temporarily might expand the over-all memory
* footprint, it properly cleans up after itself.
* 
********
        int f6(char *item1)
{
    my_class c1;
    int result;
            ...
    c1 = new my_class(item1);
    ...
            result = c1.x;
    delete c1;
    return result;
}
********
* ...
* Note that f8() is documented to return a value
* which needs to be returned to heap; as f7 thinly
* wraps f8, any code which invokes f7() must be
* careful to free() the return value.
*
********
int *f7()
{
    int *p;

    p = f8(...);
    ...
    return p;
}

static char *important_pointer = NULL;
void f9()
{
if (!important_pointer) 
important_pointer = malloc(IMPORTANT_SIZE);
            ...
if (condition)
* Ooops!  We just lost the reference important_pointer already held. */
important_pointer = malloc(DIFFERENT_SIZE);
            ...
}

int main()
{
char p[5];
strcpy(p, Hello, world.");
puts(p);
}

往期推荐

长按识别二维码关注我