指针

p = & c ; 

int x = 1 , y = 2 , z[10] ; 
ip = & x ; //表明表达式*ip 的结果是 int 类型。
y = * ip ; 
* ip = 0 ; 
ip = & z[0] ; 

double *dp，atof(char *); 

*ip = *ip + 10; 

y = *ip + 1 

*ip += 1 

++*ip 

(*ip)++ 

iq = ip 

swap ( & a , & b ) ; 

void swap ( int * px , int * py ) {
    int temp ; 
    temp = * px ; 
    * px = * py ; 
    * py = temp ; 
}

int getch ( void ) { return ( bufp > 0 ) ? buf[--bufp] : getchar ( ) ; }

void ungetch ( int c ) { 
    if ( bufp >= BUFSIZE ) printf ( "ungetch:too many characters\n" ) ; 
    else buf[bufp++] = c ; 
}

int getint ( int * pn ) {
    int c , sign ; 
    while ( isspace ( c = getch ( ) ) ) ;
    if ( ! isdigit ( c ) && c != EOF && c != '+' && c != '-' ) {
        ungetch ( c ) ; return 0 ;     
    }
    sign = ( c == '-' ) ? -1 : 1 ; 
    if ( c == '+' || c == '-' ) c = getch ( ) ; 
    for ( * pn = 0 ; isdigit ( c ) ; c = getch ( ) ) 
        * pn = 10 * * pn + c - '0' ; 
    * pn *= sign ; 
    if ( c != EOF ) ungetch ( c ) ; 
    return c ; 
}

int a[10]; 

/*return length of s */
int strlen ( char * s ) {
    int n ; 
    for ( n = 0 ; * s != '\0' ; s ++ ) n ++ ; 
    return n ; 
}

strlen ( "hello world" ) ;
char array[100] ; 
strlen ( array ) ; 
char * ptr ; 
strlen ( ptr ) ; 

char s[]; 

char *s; 

f(&a[2]) 

f(a+2) 

f(int arr[]) { ... } 

f(int *arr) { ... } 

char * alloc ( int n ) {
    if ( ( allocbuf + ALLOCSIZE - allocp >= n ) ) {
        allocp += n ;
        return allocp - n ; 
    }
    else return 0 ; 
    //C语言保证，0永远不是有效的数据地址，因此返回值0可用来表示发生了异常事件
}

void afree ( char * p ) {
    if ( p >= allocbuf && p < allocbuf + ALLOCSIZE ) allocp = p ;
    //对指针进行比较
}

int strlen ( char * s ) {
    char * p = s ; 
    while ( * p != '\0' ) p ++ ; 
    return p - s ; 
}

"I am a string" 

princf("hello, world\n"}; 

char *pmessage ; 
pmessage = "now is the time" ; 

char amessage[] = "nw is the time"; /* 定义一个数组 */ 
char *pmessage = "now is the time"; /* 定义一个指针 */ 

void strcpy ( char * s , char * t ) while ( * s ++ = * t ++ ) ; 

int strcmp ( char * s , char * t ) {
    for ( ; * s == * t ; s ++ , t ++ ) if ( * s == '\0' ) return 0 ; 
    return * s - * t ; 
}

#include <stdio.h> 
#include <string.h> 
#define MAXLINES 5000 /* max #lines to be sorted */ 
char *lineptr[MAXLINES]; /* pointers to text lines */ 
int readlines(char *lineptr[], int nlines); 
void writelines(char *lineptr[], int nlines); 
void qsort(char *lineptr[], int left, int right); 
/* sort input lines */ 
main() 
{ 
    int nlines; /* number of input lines read */ 
    if ((nlines = readlines(lineptr, MAXLINES)) >= 0) { 
        qsort(lineptr, 0, nlines-1); 
        writelines(lineptr, nlines); 
        return 0; 
    } else { 
        printf("error: input too big to sort\n"); 
        return 1; 
    } 
} 
    #define MAXLEN 1000 /* max length of any input line */ 
    int getline(char *, int); 
    char *alloc(int); 
/* readlines: read input lines */ 
int readlines(char *lineptr[], int maxlines) 
{ 
    int len, nlines; 
    char *p, line[MAXLEN]; 
    nlines = 0; 
    while ((len = getline(line, MAXLEN)) > 0) 
        if (nlines >= maxlines || p = alloc(len) == NULL) 
            return -1; 
        else { 
            line[len-1] = '\0'; /* delete newline */ 
            strcpy(p, line); 
            lineptr[nlines++] = p; 
        } 
    return nlines; 
} 
/* writelines: write output lines */ 
void writelines(char *lineptr[], int nlines) 
{ 
    int i; 
    for (i = 0; i < nlines; i++) 
        printf("%s\n", lineptr[i]); 
}
void qsort(char *v[], int left, int right) 
{ 
    int i, last; 
    void swap(char *v[], int i, int j); 
    if (left >= right) /* do nothing if array contains */ 
        return; /* fewer than two elements */ 
    swap(v, left, (left + right)/2); 
    last = left; 
    for (i = left+1; i <= right; i++) 
        if (strcmp(v[i], v[left]) < 0) 
            swap(v, ++last, i); 
        swap(v, left, last); 
        qsort(v, left, last-1); 
        qsort(v, last+1, right); 
}
/* swap: interchange v[i] and v[j] */ 
void swap(char *v[], int i, int j) 
{ 
    char *temp; 
    temp = v[i]; 
    v[i] = v[j]; 
    v[j] = temp; 
}

char *lineptr[MAXLINES]; 

/* writelines: write output lines */ 
void writelines(char *lineptr[], int nlines) 
{ 
    while (nlines-- > 0) 
        printf("%s\n", *lineptr++); 
}

f(int daytab[2][13]) { ... } 

f(int daytab[][13]) { ... } 

f(int (*daytab)[13]) { ... } 

int *daytab[13] 

/* month_name: return name of n-th month */ 
char *month_name(int n) 
{ 
    static char *name[] = { 
        "Illegal month", 
        "January", "February", "March", 
        "April", "May", "June", 
        "July", "August", "September", 
        "October", "November", "December" 
    };
    return name ; 

int a[10][20]; 
int \*b[10]; 

#include <stdio.h>
#include <string.h>
#define MAXLINES 5000 /* max #lines to be sorted */
char *lineptr[MAXLINES]; /* pointers to text lines */
int readlines(char *lineptr[], int nlines);
void writelines(char *lineptr[], int nlines);
void qsort(void *lineptr[], int left, int right,
int (*comp)(void *, void *));
int numcmp(char *, char *);
/* sort input lines */
int main(int argc, char *argv[])
{
    int nlines; /* number of input lines read */
    int numeric = 0; /* 1 if numeric sort */
    if (argc > 1 && strcmp(argv[1], "-n") == 0)
        numeric = 1;
    if ((nlines = readlines(lineptr, MAXLINES)) >= 0) {
        qsort((void**) lineptr, 0, nlines-1,
            (int (*)(void*,void*))(numeric ? numcmp : strcmp));
        writelines(lineptr, nlines);
        return 0;
    } else {
        printf("input too big to sort\n");
        return 1;
    }
}
/* qsort: sort v[left]...v[right] into increasing order */
void qsort(void *v[], int left, int right,
int (*comp)(void *, void *))
{
    int i, last;
    void swap(void *v[], int, int);
    if (left >= right) /* do nothing if array contains */
        return; /* fewer than two elements */
    swap(v, left, (left + right)/2);
    last = left;
    for (i = left+1; i <= right; i++)
        if ((*comp)(v[i], v[left]) < 0)
            swap(v, ++last, i);
    swap(v, left, last);
    qsort(v, left, last-1, comp);
    qsort(v, last+1, right, comp);
}

int ( * comp ) ( void * , void * ) 

int * comp ( void * , void * ) 

#include <stdlib.h>
/* numcmp: compare s1 and s2 numerically */
int numcmp(char *s1, char *s2)
{
    double v1, v2;
    v1 = atof(s1);
    v2 = atof(s2);
    if (v1 < v2)
        return -1;
    else if (v1 > v2)
        return 1;
    else
        return 0;
}

void swap(void * v[], int i, int j;)
{
    void *temp;
    temp = v[i];
    v[i] = v[j];
    v[j] = temp;
}

extern void \*malloc(unsigned int num\_bytes);

#include<malloc.h>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>

using namespace std ; 

struct node {
    int value ; 
    struct node * next ; 
} ; 

typedef struct node Node ; 
//创造节点
Node * create_node ( Node * head , int value ) {
    Node * t_node = ( Node * ) malloc ( sizeof ( Node ) ) ; //千万不可自己去计算数据填入!!!
    if ( ! t_node ) { printf ( "failed" ) ; exit ( -1 ) ; }
    t_node -> value = value ; // ( * t_node ).value ; 
    t_node -> next = head ; //
    return t_node ; 
}
//搜索目标节点
Node * search_node ( int val , Node * head ) {
    for ( Node * p = head ; p ; p = p -> next ) {
        if ( p -> value == val ) return p ; 
    }
    return 0 ; 
}
//删除节点，直接越过目标节点进行连接
Node * delete_node ( Node * head , int n ) {
    Node * pre , * cur ;
    for ( pre = 0 , cur = head ; cur && cur -> value != n ; pre = cur , cur = cur -> next ) ; 
    if ( ! cur ) return head ; 
    if ( ! pre ) head = head -> next ; 
    else pre -> next = cur -> next ; 
    free ( cur ) ; cur = NULL ; //指向NULL养成好习惯
    return head ; 
}

int main ( ) {
    Node * head = 0 ;  
    while ( 1 ) {
        int val ; scanf ( "%d" , & val ) ; 
        if ( val == -1 ) break ; 
        head = create_node ( head , val ) ;
    }
    int find_val ; scanf ( "%d" , & find_val ) ; 
    Node * goal = search_node ( find_val , head ) ; 
    return 0 ; 
}