C陷阱与缺陷

struct {
	int part_number;
	char *descripiton;
}parttab[] ={
	046, "des1",
	047, "des2",
	123, "des3"
}

int i, a[10];
for(i = 1; i < 10; i++)
	a[i] = 0;

#include <stdio.h>
#include <string.h>

#define N 3
static char buffer[N];
char *bufPtr = &buffer[0];

void memCpy(char *dst, char *src, size_t n);
void bufWrite(char *p, size_t n);
void flushBuf(void);

int main(int argc, const char * argv[]) {
    // insert code here...
    memset(buffer, 0, sizeof(buffer));
    char *msg = "Hello From wcw!\n";
    bufWrite(msg, strlen(msg));
    
    getchar();
    return 0;
}

void memCpy(char *dst, char *src, size_t n){
    while(--n > 0)
        *dst++ = *src++;
}

void bufWrite(char *p, size_t n){
    while(n > 0){
        fprintf(stdout, "%zu %s\n",n ,buffer);
        long k;
        long rem = 0;
        if(bufPtr == &buffer[N])
            flushBuf();
        rem = buffer + N - bufPtr;
        k = n > rem ? rem : n;
        memCpy(bufPtr, p, k);
        bufPtr += k;
        p += k;
        n -= k;
    }
}

void flushBuf(void){
    bufPtr = &buffer[0];
    fflush(stdout);
}

void bufWrite(char *p, size_t n){
  while(--n > 0){
    int k, rem;
    rem = buffer + N - bufPtr;
    k = n > rem ? rem : n;
    memCpy(bufPtr, p, k);
    if(k == rem) flushBuf();
    else bufPtr += k;
    n -= k;
    if(n) p += k;
  }
}

#include <stdio.h>

#define NCOLS 4
#define NROWS 4
#define BUFSIZE (NROWS * (NCOLS - 1))
static int buffer[BUFSIZE];
static int *bufPtr = buffer;


void memCpy(int *dst, int *src, size_t n);
void bufWrite(int *p, size_t n);
void flushBuf(void);

void flush(void);
void printnum(int n);
void printnl(void);
void printpage(void);


#define N 20
int main(int argc, const char * argv[]) {
    // insert code here...
    int msg[20];
    for(int i = 0; i < N; i++)
        msg[i] = i;
    bufWrite(msg, N);

    flush();
    getchar();
    return 0;
}

void flush(){
    long row;
    long k = bufPtr - buffer;
    if(k > NROWS) k = NROWS;
    if(k > 0){
        for(row = 0; row < k; row++){
            int *p;
            for(p = buffer + row; p < bufPtr; p += NROWS)
                printnum(*p);
            printnl();
        }
        printpage();
    }
}

void memCpy(int *dst, int *src, size_t n){
    while(--n > 0)
        *dst++ = *src++;
}

void bufWrite(int *p, size_t n){
    while(n > 0){
        long k;
        long rem = 0;
        if(bufPtr == &buffer[BUFSIZE])
            flushBuf();
        rem = buffer + BUFSIZE - bufPtr;
        k = n > rem ? rem : n;
        memCpy(bufPtr, p, k);
        bufPtr += k;
        p += k;
        n -= k;
    }
}

void flushBuf(void){
    bufPtr = &buffer[0];
    fflush(stdout);
}

void printnum(int n){
    fprintf(stdout, "%4d ", n);
}

void printnl(){
    fprintf(stdout, "\n");
}

void printpage(){
    fprintf(stdout, "$\n");
}

int i = 0;
while(i < tabsize && tab[i] != x)
	i++;

int i = 0;
while(i < tabsize & tab[i] != x)
	i++;

int *binarySearch(int *p, size_t n, int x){
  int lo = 0;
  int hi = n - 1;
  while(lo <= hi){
    int mid = (hi + lo) >> 1;
    if(x < p[mid])
      hi = mid - 1;
    else if(x > p[mid])
      lo = mid + 1;
    else
      return p + mid;
  }
  return NULL;
}

int *binarySearch(int *p, size_t n, int x){
  int *lo = p;
  int *hi = p + n;
  while(lo < hi){
    int *mid = lo + ((hi - lo) >> 1);
    if(x < *mid)
      hi = mid - 1;
    else if(x > *mid)
      lo = mid + 1;
    else
      return mid;
  }
  return NULL;
}

a = 1;
void function(){
	print("Definition\n");
}

# double function();
printf("%g\n", function());

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main(int argc, char **argv){
	int i = pow(2, atoi(argv[1]);
	char c;
	printf("%d\n", i);
	scanf("%d", &c);
	printf("%d\n", i);
	return 0;
}

#include <stdio.h>
 
int main(int argc, char **argv){
    unsigned int x = 1;
    char *endian;
    endian = (int) ( ((char *)&x)[0]) == 1 ? "little" : "big";
    printf ("%s endian\n", endian);
 
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <math.h>
#include <errno.h>


int main(int argc, char **argv){
    
    const char *zens[] = {
        "Beautiful is better than ugly." ,
        "Explicit is better than implicit." ,
        "Simple is better than complex." ,
        "Complex is better than complicated." ,
        "Flat is better than nested." ,
        "Sparse is better than dense." ,
        "Readability counts." ,
        "Special cases aren't special enough to break the rules." ,
        "Although practicality beats purity." ,
        "Errors should never pass silently." ,
        "Unless explicitly silenced." ,
        "In the face of ambiguity, refuse the temptation to guess." ,
        "There should be one-- and preferably only one --obvious way to do it." ,
        "Although that way may not be obvious at first unless you're Dutch." ,
        "Now is better than never." ,
        "Although never is often better than *right* now." ,
        "If the implementation is hard to explain, it's a bad idea." ,
        "If the implementation is easy to explain, it may be a good idea." ,
        "Namespaces are one honking great idea -- let's do more of those!",
        NULL};
    
    int i = 0;
    char buffer[100];
    char *file = "file.txt";
    
    FILE *fp;
    fp = fopen(file, "w");
//    fputs(zens[i], fp);
    fwrite(zens[i], strlen(zens[i]) + 1, 1, fp);
    fclose(fp);
    
    fp = fopen(file, "r+");
    
    while(fread(buffer, strlen(zens[i]) + 1 , 1, fp) == 1){
        printf("r: %s\n", buffer);
        if(zens[i + 1] != NULL){

            fseek(fp, -(long)(strlen(zens[i]) + 1), SEEK_CUR);
            i++;
            fwrite(zens[i], strlen(zens[i]) + 1 , 1, fp);
            printf("w: %s\n", zens[i]);
            fseek(fp, 0L, SEEK_SET);
        }
        else break;
    }
    fclose(fp);
    
    return 0;
}

#include <stdio.h>
int main(){
  static char buf[BUFSIZ];
  setbuf(stdout, buf);
  puts("block buffer\n");
  // fflush(stdout);
  getchar();
  return 0;
}

if (somecall() == -1) {
    int errsv = errno;
    perror("somecall() failed\n");
    if (errsv == ...) {
        fprintf(stderr, "some call() failed: %s\n", strerror(errsv));
    }
}

static int tmp1, tmp2;
#define MAX(x, y) (tmp1 = (x), tmp2 = (y), \
        tmp1 > tmp2 ? tmp1 : tmp2)

void printneg(long n, void (*p)())
{
    long q;
    int r;
    q = n / 10;
    r = n % 10;
    if(r > 0)
    {
        r -= 10;
        q++;
    }
    if(n <= -10) printneg(q, p);
    (*p) ("0123456789"[-r]);
}
printnum (long n, void (*p)())
{
    if(n < 0)
    {
        (*p) ('-');
        printneg(n, p);
    }
    else
        printneg(-n, p);
}

int printf(char *fmt){
  va_list ap;
  va_start(ap, fmt);
  int n = vprintf(fmt, ap);
  va_end(ap);
  return n;
}