C++博客-刘加加在成长(C语言学习中)-随笔分类-学习C语言

sprint() 格式化写入字符串

刘加加 — Fri, 30 May 2008 16:01:00 GMT

程序从读取用户输入的firstname,lastname和prize,并将他们读取的值按照一定格式存储到另一个字符串数组内。

#include<stdio.h>
#define MAX 20
int main(void)
{
    char first[MAX];
    char last[MAX];
    char formal[2*MAX+10];
    double prize;

    puts("Enter your first name");
    gets(first);
    puts("Enter your last name");
    gets(last);
    puts("Enter your prize money");
    scanf("%lf",&prize);
    sprintf(formal,"%s,%-19s:$%6.2f\n",last,first,prize);
    puts(formal);

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

刘加加 2008-05-31 00:01 发表评论

strcpy() 复制字符串

刘加加 — Fri, 30 May 2008 15:57:00 GMT

下面代码演示了程序循环从用户输入读取字符串，并存入临时的字符串数组，然后将临时字符串复制到qwords数组里面。

#include<stdio.h>
#include<string.h>
#define SIZE 40
#define LIM 5
int main(void)
{
    char qwords[LIM][SIZE];
    char temp[SIZE];
    int i=0;

    while(i<LIM && gets(temp))
    {
        strcpy(qwords[i],temp);
        i++;
    }
    puts("The list");
    for(i=0;i<LIM;i++)
    {
        puts(qwords[i]);
    }

    getchar();
    return 0;
}

刘加加 2008-05-30 23:57 发表评论

strcmp() 比较字符串的内容

刘加加 — Fri, 30 May 2008 15:48:00 GMT

下面程序使用strcmp()验证答案是否正确：

    char try[10];

    puts("Who is 1+1?");
    gets(try);
    while(strcmp(try,"2")!=0)
    {
        puts("No,it's wrong.Try again.");
        gets(try);
    }
    puts("OK,That's right");

下面程序说明各种情况下，strcmp()的返回值：

printf("strcmp(\"a\",\"a\")=%d\n",strcmp("a","a"));
    printf("strcmp(\"a\",\"b\")=%d\n",strcmp("a","b"));
    printf("strcmp(\"b\",\"a\")=%d\n",strcmp("b","a"));
    printf("strcmp(\"a\",\"c\")=%d\n",strcmp("a","c"));
    printf("strcmp(\"c\",\"a\")=%d\n",strcmp("c","a"));
    printf("strcmp(\"abc\",\"abd\")=%d\n",strcmp("abc","abd"));
    printf("strcmp(\"abc\",\"abcd\")=%d\n",strcmp("abc","abcd"));
    printf("strcmp(\"abc\",\"abbd\")=%d\n",strcmp("abc","abbd"));

刘加加 2008-05-30 23:48 发表评论

strcat()函数

刘加加 — Tue, 27 May 2008 12:12:00 GMT

strcat()接受两个字符串参数。将第二个字符串的一份拷贝添加到第一个字符串的结尾，从而使第一个字符串成为一个新的组合字符串，第二个字符串不改变。

#include<stdio.h>
#include<string.h>
int main(void)
{
    char string1[20];
    char string2[]="goodbye";

    gets(string1);
    strcat(string1,string2);
    puts(string2);
    puts(string1);

    getchar();
    return 0;
}

以上程序将string2字符串的拷贝放到了string1的结尾。

值得注意的是，string1在被使用strcat()函数之前，应该是已经初始化或者已经存储了一个字符串。因为如果字符串没有被初始化，string1[]里面元素的存储是一串随机值。strcat()需要找到string1的结尾（第一个出现的'\0'）,然后去掉这个'0',最后把string2[]的拷贝放到string1[]最后一个值的后面。

刘加加 2008-05-27 20:12 发表评论

使用strlen()获得字符串长度

刘加加 — Tue, 27 May 2008 11:32:00 GMT

函数原型：size_t strlen(const char*)
作用：返回参数中字符串的长度。

以下代码是一个截取字符串的例子：

#include<stdio.h>
#include<string.h>
void fit(char *,int);
int main(void)
{
    char msg[]="Hello moto";

    puts(msg);
    fit(msg,5);
    puts(msg);
    puts(msg+6);
    getchar();
    return 0;
}
void fit(char *string,int size)
{
    if(strlen(string)>size)
    {
        *(string+size)='\0';
    }
}

截取前：

space

截取后

fit()是截取字符串的方法。如果字符串的长度大于要截取的长度，那么将指向该字符串的指针向后移动size位后，将指针指向的内容置为'\0'，即字符串结束。但string+size+1处仍然存在一个字符串。

刘加加 2008-05-27 19:32 发表评论

初步认识数组、指针和字符串关系

刘加加 — Fri, 23 May 2008 16:27:00 GMT

字符串数组初始化：
(1)char arr[10]="HI";
初始化字符串数组时，编译器自动将字符串最后一个字符后面加上'\0',以表示字符串的结束。
如果数组的大小大于字符串的长度+1，那么把字符串结束后面的元素也都初始化为'\0';
看这段程序：
定义一个大小为12的字符串数组
char str1[12]="jiajia";
让一个char型的指针指向这个数组
    char *p1=str1;
输出这个字符串
    printf("%s\n\n",str1);
利用指针输出这个字符串数组中每个元素的字符、字符ascii值、字符存储地址
    for(int i=0;i<12;i++)
    {
        printf("%c:%d:%p\n",*p1,*p1,p1);
        p1++;
    }
可以看出，数组元素的后几位都被初始化成了'\0';使用printf打印字符串数组时，程序遇到第一个'\0'就结束对字符串的读取。

如果数组的大小小于字符串的长度+1，程序在运行时可能要出现问题，所以应当确保数组的大小要大于字符串长度的大小+1；

这段程序的字符串长度+1小于数组的大小：
char str2[12]="hello jiajia";
    char *p2=str2;

    printf("\n\n\n%s\n\n",str2);

    for(int i=0;i<28;i++)
    {
        printf("%c:%d:%p\n",*p2,*p2,p2);
        p2++;
    }

使用printf打印字符串，程序需要找到'\0'才能结束读取，结果找遍整个数组没有找到，只有继续顺着地址寻找，一直找到某个地址上的assii是0的，字符串才读取完毕。所以本段程序在读取完"hello jiajia"之后，后面可能还会有几个随机的字符，就是因为字符串终止于'\0'。

(2)char arr[]="Hello World!";
这种初始化方法不用担心数组大小过小的情况，数组的大小由编译器决定。
(3)char arr[]={'H','e','e','l','o',' ','W','o','r','l','d','\0'};
同第二种方法结果相同，但显然要麻烦许多。另外，' '代表空格，ascii值是32，'\0'代表字符串结束，ascii值是0；
(4)char *p="Hello World";
使用数组的方式初始化。同数组不同之处在于,p是一个变量，可以做递增、递减运算，而arr是数组的首地址，是一个地址常量，不能做递增、递减运算。

char *name="liujiajia";
    name[0]='L';
    printf("\n%s\n",name);
name[0]='L';这句代码在最新的c99标准中会引发程序异常。需要注意。

char *string="c programe";
    char *string2;
    string2=string;    //将指针string的值赋给string2

    printf("\nstring=%s,&string=%p,string=%p\n",string,&string,string);
    printf("\nstring=%s,&string=%p,string=%p\n",string2,&string2,string2);

上面这段程序最后显示，指针string所指向的地址和指针string2所指向的地址相同，这就说明它们指向的是内存里面同一个字符串，也就是说字符串本身并没有复制，而是产生了一个指向同一个字符串的指针。这样程序的效率会更加的高。如果需要复制字符串可以使用 strcpy() 或 strncpy()。

刘加加 2008-05-24 00:27 发表评论

函数和二维数组的新认识(参数指定数组第二维和第一维大小)

刘加加 — Tue, 20 May 2008 14:31:00 GMT

#include<stdio.h>
#define ROWS 3
#define COLS 4
void sum_rows(int arr[][COLS],int rows);
int main(void)
{
    int junk[ROWS][COLS]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};

    sum_rows(junk,ROWS);//求出每行的数值总和。

    getchar();
    return 0;
}
void sum_rows(int arr[][COLS],int rows)
{
    int r,c,tot;
    for(r=0;r<rows;r++)
    {
        tot=0;
        for(c=0;c<COLS;c++)
        {
            tot+=arr[r][c];
        }
        printf("row%d,sum=%d\n",r,tot);
    }
}

我们都知道上面的代码可以顺利执行， sum_rows()的形参是 int arr[][COLS],没有指定数组的第一维大小。但是设想一下，如果不指定第二维的大小，结果会怎样呢？
我写了以下例子：

#include <stdio.h>
int sum2d(int arr[][],int row,int col);
int main(void)
{
    int arr[3][4]={{1,2,3,5},{3,4,4,5},{2,3,4,5}};
    sum2d(arr,3,4);

    getchar();
    return 0;
}
int sum2d(int arr[][],int row,int col)
{
    for(int i=0;i <row;i++)
    {
        for(int j=0;j <col;j++)
        {
            printf("%d",arr[i][j]);  invalid use of array with unspecified bounds
        }
    }
    return 0;
}

运行后发现，程序报错了，这是为什么呢？百思不得其解，后来请教了CSDN上老大们。终于稍微弄明白了点儿。我想具体应该从两方面证明为什么上面的程序不可行。
（1）从二维数组的存储方式上：二维数组在内存上是一行一行连续的存储的。如下图：
arr[3][4]

arr[0][0]

arr[0][1]

arr[0][2]

arr[0][3]

arr[1][0]

arr[1][1]

arr[1][2]

arr[1][3]

...

因为arr是这个数组的首地址，我们可以知道arr[0][0]的地址。只要我们知道arr[][4]中数组第二维的大小‘4’，我们就可以找到任意行和列的地址。address=arr+(rows-1)*4+cols。但是如果不知道第二维的大小，那么条件就不够了。打一个比方，将若干个学生分成每组11人，并让他们站成一排，这时我们可以定位出第几组的第几个学生。但如果不知道每组11个人，那么我们显然就无法定位了。

（2）从指针的角度上看(这种思路我还是有点迷糊):大家可以参看这个帖子：http://topic.csdn.net/u/20080520/09/2122e210-5cf5-4b75-b31f-c2523b00cf53.html?575319732

恩，现在是越学越迷惑了。呵呵。

刘加加 2008-05-20 22:31 发表评论

函数和二维数组

刘加加 — Mon, 19 May 2008 15:03:00 GMT

阅读下面代码，程序列举了3种二维数组作为参数传递的方法：

#include<stdio.h>
#define ROWS 3
#define COLS 4
void sum_rows(int arr[][COLS],int rows);
void sum_cols(int [][COLS],int);        //可以省略名称
int sum2d(int (*arr)[COLS],int rows);   //另一种语法形式
int main(void)
{
    int junk[ROWS][COLS]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};

    sum_rows(junk,ROWS);//求出每行的数值总和。
    printf("\n");       //求出每列的数值总和。
    sum_cols(junk,ROWS);//求出全部数值的总和。

    printf("\nthe sum of the junk is %d",sum2d(junk,ROWS));

    getchar();
    return 0;
}
void sum_rows(int arr[][COLS],int rows)
{
    int r,c,tot;
    for(r=0;r<rows;r++)
    {
        tot=0;
        for(c=0;c<COLS;c++)
        {
            tot+=arr[r][c];
        }
        printf("row%d,sum=%d\n",r,tot);
    }
}
void sum_cols(int arr[][COLS],int rows)
{
    int r,c,tot;
    for(c=0;c<COLS;c++)
    {
        tot=0;
        for(r=0;r<rows;r++)
        {
            tot+=arr[r][c];
        }
        printf("col%d,sum=%d\n",c,tot);
    }
}

int sum2d(int (*arr)[COLS],int rows)
{
    int r,c,tot=0;
    for(r=0;r<rows;r++)
    {
        for(c=0;c<COLS;c++)
        {
            tot+=arr[r][c];
        }
    }
    return tot;
}

刘加加 2008-05-19 23:03 发表评论

指针和多维数组

刘加加 — Mon, 19 May 2008 14:28:00 GMT

一、多维数组地址和指针的关系
int arr2[4][2]={{1,2},{3,4},{5,6},{7,8}};
printf("arr2=%p,&arr2[0]=%p,arr2[0]=%p,&ar2r[0][0]=%p\n",arr2,&arr2[0],arr2[0],&arr2[0][0]);

arr[0][0] (1)	arr[1][0] (3)	arr[2][0] (5)	arr[3][0] (7)
arr[0][1] (2)	arr[1][1] (4)	arr[2][1] (6)	arr[3][1] (8)

上面的程序的结果输出竟然都一样。为什么呢？
首先 arr2 代表的是arr2数组的首地址，所以 arr2的值和 arr2第一个子元素arr2[0]的地址相同，即 &arr2[0]；
arr2[0]是含有两个整形元素一维数组的首地址，即&arr2[0][0]的值。
简单的说：arr[0]是一个整数大小对象的地址，arr2是两个整数大小对象的地址。因为整数和两个整数组成的数组开始于同一个地址，所以 arr2 和 arr2[0] 具有相同的数值。

二、指针（地址）运算和多维数组的关系
printf("arr2+1=%p,arr2[0]+1=%p\n",arr2+1,arr2[0]+1);
现在我们知道，arr2 和 arr2[0]具有相同的数值，但是arr2+1和arr2[0]+1为什么数值不一样呢？这是因为，arr2指向的对象大小是两个int，儿arr2[0]所指向的大小是一个int。所以arr2+1的值要比arr2[0]+1的值多一个int大小。

三、使用*对多维数组取值
因为 arr2[0] 是 arr2[0][0]的首地址，所以 *(arr2[0])代表存储在arr2[0][0]的值。同样，arr2是arr2[0]的首地址，*arr就是 arr2[0]的值。但是 arr2[0]也是一个地址，即&arr2[0][0],因此*arr2是 &arr2[0][0]。所以 *&arr2[0][0] 等价于 **arr2。*&arr2[0][0] 可以简化为 arr2[0][0]。所以 arr2[0][0]==**arr2。
简而言之：arr2是地址的地址，所以需要经过两次取值才能取到具体的数值。

学完这个知识点，才发现在指针确实很难懂。

刘加加 2008-05-19 22:28 发表评论

指针的基本运算

刘加加 — Mon, 19 May 2008 11:08:00 GMT

对指针可以进行赋值、求值或取值、取指针的地址、将一个指针加上一个整数、增加指针的值、求差值的操作。请参看以下代码展示了几种情形：

#include<stdio.h>
int main(void)
{
    int urn[5]={100,200,300,400,500};
    int *p1,*p2,*p3;

    p1=urn;         //把一个地址赋给指针
    p2=&urn[2];     //取得urn[2]的地址，并赋给一个指针

    printf("数组各个元素的值和地址：\n");
    for(int i=0;i<5;i++)
    {
        printf("urn[%d]=%d   &urn[%d]=%p;\n",i,urn[i],i,&urn[i]);
    }

    printf("\n指针指向的地址,指针指向地址的值,指针的地址\n");
    printf("p1=%p    ,*p1=%d         ,&p1=%p",p1,*p1,&p1);

    printf("\n指针加上整数的效果(指针+int!=指针，指针+int==地址)：\n");
    printf("p1+4=%p,*(p1+4)=%d",p1+4,*(p1+4));

    //printf("&(p1+4)=%p",&(p1+4))//error:p1+4是一个地址，不能对其进行取地址操作，但可以将p1+4赋给一个指针

    p1++;//p++==p1+1。p1+1是一个地址，将p1+1赋给p1
    printf("\n在p1++以后：\np1=%p    ,*p1=%d         ,&p1=%p\n",p1,*p1,&p1);

    //求两个指针差值
    printf("\np2=%p,p1=%p,p2-p1=%d\n",p2,p1,p2-p1);

    getchar();
    return 0;
}

刘加加 2008-05-19 19:08 发表评论

带有数组类型参数的函数

刘加加 — Fri, 16 May 2008 15:54:00 GMT

传递数组参数，其核心就是传递该数组的首地址。然后函数再通过数组、指针等，用该数组的首地址构造一个新的数组或指针，再通过传递过来的数组大小，对该数组进行操作。

#include <stdio.h>
#define SIZE 4
int sumbyarr(int a[],int n);
int sumbypointer(int *p,int n);
int sumbyaddress(int address,int n);
int sumbypointer2(int *begin,int *end)
int main(void)
{
    int arr[SIZE]={10,20,30,40};
    int sum1;
    //使用数组作为形参接收数组
    sum1=sumbyarr(arr,SIZE);
    printf("the total of the arr by array is:%d\n",sum1);
    //使用指针作为形参接收数组
    int sum2;
    sum2=sumbypointer(arr,SIZE);
    printf("the total of the arr by pointer is:%d\n",sum2);
    //使用地址作为形参接收数组
    int sum3;
    sum3=sumbyaddress(arr,SIZE);
    printf("the total of the arr by address is:%d\n",sum3);

    //使用两个指针形参接收
    int sum4;
    sum4=sumbypointer2(arr,arr+SIZE);
    printf("the total of the arr by pointer2 is:%d\n",sum4);

    getchar();
    return 0;
}
int sumbyarr(int a[],int n)
{
    int index;
    int total=0;
    for(index=0;index<n;index++)
    {
        total+=a[index];
    }
    return total;
}
int sumbypointer(int *p,int n)
{
    int index;
    int total=0;
    for(index=0;index<n;index++,p++)
    {
        total+=*p;
    }
    return total;
}
int sumbyaddress(int address,int n)
{
    int *p=address;
    int index;
    int total=0;
    for(index=0;index<n;index++,p++)
    {
        total+=*p;
    }
    return total;
}
int sumbypointer2(int *begin,int *end)
{
    int total=0;
    while(begin    {
        total+=*begin;
        begin++;
    }
    return total;
}

以上代码演示怎样定义有数组作为参数的函数。
如果数组作为参数传递进入某个函数，并且在这个函数中改变了数组元素的值，那么程序返回后，这个数组元素的值有没有改变呢？

当然，值改变了，因为数组是通过地址传递的，改变了被调函数中数组的值也就意味着同时改变了主调函数中数组的值。因为它们的地址是相同的。

刘加加 2008-05-16 23:54 发表评论

认识数组和指针的关系

刘加加 — Fri, 16 May 2008 13:30:00 GMT

   int arr[SIZE]={1,2,3,4};
    int index;
    for(index=0;index    {
        printf("arr[%d]=%d address=%p\n",index,arr[index],arr+index);
    }

    int *p=arr;
    for(index=0;index    {
        printf("*(p+%d)=%d     p+%d=%p\n",index,*(p+index),index,p+index);
    }

    getchar();
    return 0;

以上代码展示了读取数组中元素的两种方式，第一种是常规的使用数组下标来读取。第二种方法是使用指针来读取数组。

通过第一中方法中打印出来的内容，我们可以认识到，数组名其实就是这个数组的首地址，即：arr=数组首地址;arr+1:数组第二个元素的地址；arr+2：数组第三个元素的地址，以此类推。。。

第二种方法我们使用指针访问代替了数组下标访问，我们将 arr(即数组的首地址)赋值给了指针 *p，所以 p就等于arr的首地址，p+1就等于arr的二个元素的地址，那么*p就相当于了arr[0],*(p+1)就相当于arr[1]。

我们从中可以得出一个结论：数组标记实际上是一种变相使用指针的形式。

刘加加 2008-05-16 21:30 发表评论

二维数组简单使用

刘加加 — Thu, 15 May 2008 16:06:00 GMT

#include<stdio.h>
#define PLAYER 4
#define MATCH 3
int main(void)
{
    //将4名球员近三场比赛的得分初始化
    int arrmark[MATCH][PLAYER]={
        {9,8,7,5},
        {8,10,8,7},
        {7,7,10,6}
        };
    //输出具体成绩
    int i,j;
    printf("***********Roony  Ronaldo  Kaka  Grosso\n");
    for(i=0;i<MATCH;i++)
    {
        printf("match%d:",i);
        for(j=0;j<PLAYER;j++)
        {
            printf("%8d",arrmark[i][j]);
        }
        printf("\n");
    }
    //打印总分
    int temp=0;
    printf("total        ");
    for(i=0;i<PLAYER;i++)   //求每个球员的总分
    {
        for(j=0;j<MATCH;j++)
        {
            temp+=arrmark[j][i];
        }
        printf("%d      ",temp);
        temp=0;
    }
    getchar();
}

刘加加 2008-05-16 00:06 发表评论

指定数组大小

刘加加 — Thu, 15 May 2008 15:32:00 GMT

指定数组大小也有很多方式：
    char arr[10];                                    //OK
    char arr2[1+2*7];                            //OK
    char arr3[sizeof(char)+2];                //OK
    char arr4[-2];                                  //error 数组大小不能使用负数
    char arr5[0];                                   //根据编译器不同，有的编译器转换为“arr5[]”,有的编译不通过。
    char arr6[3.14];                            //error
    char arr7[(int)3.14];                       //强制转换为int
    int m=2;
    char arr9[m];                                //c99前不允许

注意：c99标准允许使用变量指定数组大小。

刘加加 2008-05-15 23:32 发表评论

认识数组之数组的初始化

刘加加 — Thu, 15 May 2008 15:11:00 GMT

以下代码展示数组初始化的各种情况：

#include<stdio.h>
#define SIZE 4
int main(void)
{
    //一般初始化
    int arr[SIZE]={1,2,3,4};
    int index;
    for(index=0;index<SIZE;index++)
    {
        arr[index]++;
        printf("arr[%d]=%d\n",index,arr[index]);
    }

    //定义并初始化一个const数组。数组内元素不能修改
    int const arr2[SIZE]={1,2,3,4};

    //数组不初始化，元素的值为随机数。
    int arr3[SIZE];
    for(index=0;index<SIZE;index++)
    {
        printf("arr3[%d]=%d\n",index,arr3[index]);
    }

    //如果初始化数组中部分元素，其他元素则被初始化为0
    int arr4[SIZE]={1,2};
    for(index=0;index<SIZE;index++)
    {
        printf("arr4[%d]=%d\n",index,arr4[index]);
    }
    //指定要初始化的元素
    int arr5[SIZE]={1,[2]=3,[3]=4};
    for(index=0;index<SIZE;index++)
    {
        printf("arr5[%d]=%d\n",index,arr5[index]);
    }

    //数组的元素个数不固定
    int arr6[]={1,2,3,4,5,6,7,8};
    printf("sizeof arr6=%d,sizeof arr6[0]=%d\n",sizeof arr6,sizeof arr6[0]);
    for(index=0;index<sizeof arr6/sizeof arr6[0];index++)
    {
        printf("arr6[%d]=%d\n",index,arr6[index]);
    }
    return 0;
}

程序运行结果是：

怎么样？数组的初始化方式多种多样。但要灵活运用。

刘加加 2008-05-15 23:11 发表评论

认识sizeof

刘加加 — Thu, 15 May 2008 08:01:00 GMT

sizeof 是C语言里面的一个运算符，并且以字节为单位返回其操作数的大小。操作数可以使一个具体的数据对象、变量类型、一个操作数。并且返回类型为size_t，size_t是在stddef.h头文件里定义的，原型是：typedef unsigned int size_t;
以下代码演示sizeof用法：

#include<stdio.h>
#include<stddef.h>
#include<stdlib.h>
int main(void)
{
    int i;
    printf("sizeof(2008)=%d\n",sizeof(2008));
    printf("sizeof(i)=%d\n",sizeof(i));
    printf("sizeof i=%d\n",sizeof i);
    printf("sizeof(int)=%d\n",sizeof(int));
    //printf("sizeof int=%d\n",sizeof int); //sizeof int写法错误！
    printf("sizeof(char)=%d\n",sizeof(char));
    printf("sizeof(float)=%d\n",sizeof(float));
    printf("sizeof(double)=%d\n",sizeof(double));

    return 0;
}

运行结果显示：

另外，sizeof 可以应用于数组、结构等情况，请参考这篇文章：http://blog.chinaunix.net/u/20828/showart_438003.html

刘加加 2008-05-15 16:01 发表评论

认识递归函数

刘加加 — Tue, 13 May 2008 16:08:00 GMT

#include<stdio.h>
void testfunc(int);
int main(void)
{
    testfunc(1);
    return 0;
}
void testfunc(int n)
{
    printf("Lv%d:%p\n",n,&n); //%p 地址显示格式
    if(n<4)
    {
        testfunc(n+1);  //testfunc()调用了自己
    }
    printf("2Lv%d:%p\n",n,&n);
}

以上是一个递归的示例。
testfunc()在内部调用了自己，这样的后果是：暂时不执行最后面的“printf("2Lv%d:%p\n",n,&n);”，而是将 n+1作为参数调用了自己，这样重复，最终程序的结果是：

(根据电脑不同，地址可能有所不同)
程序具体运行步骤：
1.main()调用testfunc(1)
2.testfunc(1)执行，打印“lv1:0022FF60”，0022FF60是n的地址
3.n<4,条件成立， testfunc(1)调用testfunc(2)
4.testfunc(2)执行，打印“lv1:0022FF40”,因为此时testfunc(2)的变量n已经不是testfunc(1)中的变量n了，所以地址不同。（函数的参数作用域只在当前函数）
5.n<4，条件成立，testfunc(2)调用testfunc(3)
6.testfunc(3)执行，打印“lv1:0022FF20”
7.n<4，条件成立，testfunc(3)调用testfunc(4)
8.testfunc(4)执行，打印“lv1:0022FF00”
9.n<4,条件不成立，打印“2lv1:0022FF00”
10.返回调用testfunc(4)的testfunc(3),打印“2lv1:0022FF20”
11.返回调用testfunc(3)的testfunc(2),打印“2lv1:0022FF40”
12.返回调用testfunc(2)的testfunc(1),打印“2lv1:0022FF60”

OK,这就是函数的递归调用，通俗的说就是函数自己调用自己。以前学时没有弄明白，现在终于弄明白了。

刘加加 2008-05-14 00:08 发表评论

认识getchar()和putchar()

刘加加 — Fri, 09 May 2008 14:55:00 GMT

getchar()函数没有参数，返回输入设备的下一个字符。
ch=getchar(); 和 scanf("%c",&ch);是同样的效果。

putchar()函数用来打印它的参数。
putchar(ch); 和 printf("%c",ch); 是同样的效果。

这两个函数都在 stdio.h 文件中定义了。

刘加加 2008-05-09 22:55 发表评论