Board logo

标题: [TIPS]C学习笔记 发少量谭浩强C程序设计SE课后题答案 [打印本页]

作者: 冰血封情    时间: 2004-6-25 21:07     标题: [TIPS]C学习笔记 发少量谭浩强C程序设计SE课后题答案

本例子下所有的程序都会在TC3和VC6下调试通过,并且尝试执行,学习笔记循序渐进。每周结束的时候我会把本周所有的例子全部加上题目的。如果您调试上出现了错误,请注意:例子中的所有注释使用了中文的标点,调试中会出现N多错误,请删除注释和后面的空格后再调试,方可通过。我会在后面的程序说明启动E文说明,以避免这种错误。

NO1.
复制内容到剪贴板
代码:
/*Just a practice for learning c 'for' command*/
/*输入半径求圆的周长和半径的99次方乘派*/
#include <stdio.h>
#define pi 3.14 /*宏定义*/
double sub(double r1);
void main() /*主函数是程序唯一的入口*/
{
double r,c,s,m; /*便量声明*/
printf("=======================================\n");
printf("Be powered by [email]Evilin@EvilOctal.com[/email]:)");
printf("=======================================\n");
printf("Please input r.\n");
scanf("%f",&r);
c=2*pi*r;
m=sub(r);
s=pi*m;
printf("c=%6.2f,s=%6.2f",c,s);
}
double sub(double r1) /*定义子函数*/
{
double n;
int i;
for(i=1;i<100;i++) /*循环开始*/
{
n=r1*r1; /*重复赋值给n*/
}
return(n); /*将n通过子函数带回主函数*/
}

作者: 冰血封情    时间: 2004-6-25 21:08

NO2.
#include <stdio.h>

int sub(int x1); /*定义函数模型*/
int x,m; /*全局变量*/

int main(void) /*定义主函数*/
{

printf("\ninput:");
scanf("%d",&x);
m=sub(x); /*调用函数*/
printf("m=%d\n",m);
return 0;
}
int sub(int x1) /*自定义的函数开始*/
{
int a=6,b=30,c=15,n;
if(x1<a||x1==a)
{
n=b*x1+a*a;
}
else
{
n=a*(c-x1)+c*c;
}
return (n); /*返回值带回给主函数*/
}


---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:08

NO3.
#include "stdio.h" /*头文件*/

int array[1000]; /*定义一个整型数组*/
int count; /*定义全局变量*/

int main(void) /*主函数*/
{
for(count=0;count<1000;array[count++]=50) /*利用循环给数组的每个变量赋50值*/
{
; /*定义空语句 绝不可缺少*/
}
printf("array[0] is %d",array[0]);
getchar();
return 0;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:08

N04.
#include "stdio.h"


int x;

main(void)
{
for(x=0;x<10;x++) /*利用循环输出1到9*/
{
printf("\nthe value of x is %d",x); /*这个是输出的方法*/
}
getchar(); /*停顿读取一个键盘键继续*/
return 0;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!

程序输出结果:

the value of x is 0
the value of x is 1
the value of x is 2
the value of x is 3
the value of x is 4
the value of x is 5
the value of x is 6
the value of x is 7
the value of x is 8
the value of x is 9

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:08

NO5.
#include "stdio.h"


int nbr=0; /*定义初始值 所以循环可以省略第一块*/

int main(void)
{
for(;nbr!=99;) /*利用循环实现 输入99才退出*/
{
scanf("%d",&nbr);
}
return 0;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:09

NO6.
#include "stdio.h"

int value[10];

int ctr,nbr=0;

int main(void)
{
for(ctr=0;ctr<10&&nbr!=99;ctr++) /*大于10和等于99的情况退出*/
{
puts("\nEnter a number, 99 2 quit:");
scanf("%d",&nbr);
value[ctr]=nbr; /*数组开始赋值*/
}
return 0;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:09

NO7.
#include <stdio.h> /*头文件*/


void draw_box(int,int); /*定义函数类型*/

int main(void) /*主函数*/
{
draw_box(8,35); /*调用函数并且定义了row的初始值*/
getchar();
return 0;
}
void draw_box(int row,int column) /*函数开始*/
{
int col;
for(;row>0;row--) /*开始循环*/
{
for(col=column;col>0;col--) /*嵌套的第二个循环*/
printf("x"); /*前面都满足则打印一个X*/
printf("\n"); /*嵌套的循环完成后回车*/
}
}

程序输出结果:
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX


---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:09

NO8.
#include "stdio.h"

int count;

int main(void) /*the main function*/
{
count=1;
while(count<=20)
{
printf("%d",count++); /*print the numbers 1 through 20*/
printf("\n");
}
return 0;
} /*end of program*/

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!

程序输出结果:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
作者: 冰血封情    时间: 2004-6-25 21:10

NO9.
#include "stdio.h"
int count;
int main(void)
{
for(count=1;count<=20;count++) /*Print the numbers 1 through 20*/
{
printf("\n%d",count);
}
return 0;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!

程序输出结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
作者: 冰血封情    时间: 2004-6-25 21:10

NO10.
#include "stdio.h"

int nbr;

int main()
{
for(nbr=0;nbr<=99;) /*如果输入的数字大于99就退出*/
{
scanf("%d",&nbr);
}
return 0;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:10

NO11.
#include "stdio.h"

int nbr=0,ctr,value[10];

int main()
{
for(ctr=0;ctr<10&&nbr!=99;)
{
puts("Enter a number, 99 to quit:"); /*输入99退出*/
scanf("%d",&nbr);
value[ctr]=nbr; /*数组赋值*/
ctr++;
}
return 0;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:11

NO12.
#include "stdio.h"
int array[5];
int main(void)
{
int ctr=0,nbr;
printf("This program prompts you to enter 5 numbers\n");
printf("Each number should be from 1 to 10\n");
while(ctr<5) /*如果ctr小于5则执行*/
{
for(nbr=0;nbr<1||nbr>10;array[ctr++]=nbr) /*如果输入的值小于1大于10则执行循环*/
{
printf("\nEnter number %d of 5:",ctr); /*提示输入数字*/
scanf("%d",&nbr); /*请求输入数字*/
printf("nbr=%d",nbr); /*输出此时的nbr值*/
}
printf("\nout!!!"); /*检测退出*/
}
for(ctr=0;ctr<5;ctr++) /*循环输出数组里的值*/
printf("value %d is %d\n",ctr,array[ctr]);
return 0;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:11

NO13.
#include <stdio.h>

int get(void); /*函数原型*/

int main(void)
{
int choice=0; /*定义变量并且赋值*/
choice=get(); /*调用函数*/
printf("You chose menu option %d\n",choice);
return 0;
}
int get(void)
{
int selection=0; /*定义函数里的变量*/
do /*开始do_while循环*/
{
printf("\n1 - Add a record");
printf("\n2 - Change a record");
printf("\n3 - Delete a record");
printf("\n4 - Quit");
printf("\n\nEnter a selection:");
scanf("%d",&selection);
}while(selection<1||selection>4); /*函数判断*/
return selection; /*把值通过函数带回主函数*/
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:12

NO14.
#include <stdio.h>

int get(void);

int main(void)
{
printf("You chose menu option %d\n",get()); /*直接调用函数来显示*/
return 0;
}
int get(void)
{
int selection=0;
while(selection<1||selection>4) /*把13例修改成了while循环*/
{
printf("\n1 - Add a record");
printf("\n2 - Change a record");
printf("\n3 - Delete a record");
printf("\n4 - Quit");
printf("\n\nEnter a selection:");
scanf("%d",&selection);
}
return selection;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:12

NO15.
#include <stdio.h>

float get(void);

int main(void)
{
printf("You chose menu option %f\n",get());
return 0;
}
float get(void)
{
float selection; /*定义为浮点型*/
for(selection=0;selection<1||selection>4;) /*把13例改成了for循环 功能与显

示都不变*/
{
printf("\n1 - Add a record");
printf("\n2 - Change a record");
printf("\n3 - Delete a record");
printf("\n4 - Quit");
printf("\n\nEnter a selection:");
scanf("%f",&selection); /*浮点型可以解决前面输入浮点型数据的死循环问题*/
}
return selection;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:12

NO16.
#include "stdio.h" //头文件
#define QUIT 3 //宏定义

int get_menu_choice(void); //函数原型

void print_report(void); //定义无反馈的函数原型

int main(void) //主函数开始
{
int choice=0; //定义整型变量并且赋初值为0
while(choice!=QUIT)
{
choice=get_menu_choice(); //调用函数得到choice值
if(choice==1) //如果选择等于1则执行循环
{
printf("\nBeeping the computer\a\a\a"); //连续响铃三声
}
else if(choice==2) //如果选择等于2则执行下面
{
print_report(); //调用函数打印报告
}
else //如果前面都没成功执行
{
puts("You chose to quit!");
}
}
return 0; //结束主函数
}

int get_menu_choice(void) //函数开始
{
int selection=0;
do
{
puts("\n1 - Beeping Computer");
puts("2 - Display Report");
puts("3 - Quit");
printf("\n");
puts("Enter a selection:");
scanf("%d",&selection);
}while(selection<1||selection>3); //循环判断
return selection; //将值带回主函数
}
void print_report(void) //报告函数
{
printf("\n");
puts("SAMPLE REPORT!");
printf("\n\nSequence\tMeaning");
printf("\n=========\t=======");
printf("\n\\a\t\tbell(alert)");
printf("\n\\b\t\tbackspace");
puts("\n...\t\t...");
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:13

NO17.
/*这个程序看起来似乎并不重要冰血封情还要ggyy*/
/*但是它教给你一个重要的问题%%在显示的时候是%*/
/*你应该明白为什么我用这么多废话来说明一个问题*/
/*因为他很重要在VC6下使用转译字符\%来打印%是警告*/
/*请原谅我作为一个初学者对C语言中这个问题的惊讶*/
/*如果您会了可以跳过去当然也可以嘲笑我的愚蠢*/
#include "stdio.h"
double f=1.05,g=25.5,h=-0.1;
int main(void)
{
printf("\nThe rate is %f%%",f);
return 0;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:13

NO18.
/*这个例子的确有点无聊*/
/*仅仅是为了练习函数而已*/
/*它从键盘读两个浮点数计算机他们的和*/
#include "stdio.h"

float x=0,y=0,z=0;

float take();

main(void)
{
puts("\nPlease input 2 float:");/*puts可以节省资源*/
scanf("%f,%f",&x,&y);
z=take();/*函数调用*/
printf("x*y=%f",z);
getchar();/*为了防止TC的老毛病加这句*/
return 0;
}
float take()/*函数执行必须和原型一样*/
{
float m=0;
m=x*y;
return m;/*通过函数把值带回主函数*/
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:13

NO19.
/*这个程序是从键盘读取10个数字存放在数组中*/
/*如果输入完则打印你所输入数字的最大最小值*/
/*如果一旦输入的数字是0就退出程序*/
#include "stdio.h"

int x[10],n=0,a=0,i=0;/*定义变量*/

int sub1(void);/*两个函数原型*/
int sub2(void);

int main(void)
{
puts("\nPlease input 10 int numbers:");/*不断提示输入数字*/
while(n<10)
{
printf("Input the %d number:",n);
scanf("%d",&x[n]);
if(x[n]==0)
goto f;/*这里用goto是万不得以*/
n++;
}
a=sub1();/*函数调用*/
i=sub2();
printf("Max is %d,Min is %d",a,i);/*显示你的最大最小值*/
f:getchar();
return 0;
}
int sub1(void)/*函数体*/
{
int m1=0;
for(;n>0;n--)/*循环比较此时n是9*/
{
m1=x[9];
if(m1<x[n])/*找最大值*/
m1=x[n];
}
return m1;
}
int sub2(void)
{
int m2=0;
for(;n<10;n++)/*循环比较此时n是0*/
{
m2=x[0];
if(m2>x[n])/*找最小值*/
m2=x[n];
}
return m2;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:14

NO20.
#include "stdio.h"
#include "stdlib.h"//随即函数rand在此头中定义

main(void)
{
int array[5][4],x,y;//定义了一个5行4列的数组
for(x=0;x<5;x++)//行循环
{
for(y=0;y<4;y++)//列循环
{
array[x][y]=rand();
}
}
for(x=0;x<5;x++)
{
for(y=0;y<4;y++)
{
printf("\narray[%d][%d] is %d!",x,y,array[x][y]);//循环打印所有数组的值
}
}
getch();
return 0;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:14

NO21.
//此程序打印数组所有元素的值和它的所有元素的平均值
#include "stdio.h"
#include "stdlib.h"

main(void)
{
int array[1000],x;
long sub=0;
for(x=0;x<1000;x++)
{
array[x]=rand();
sub+=array[x];//求和
}
for(x=0;x<1000;x++)
{
printf("\nThe array[%d] is %d!",x,array[x]);//打印所有元素的值
}
printf("\nThe average of array is %ld",sub/1000);//求平均
getch();
return 0;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:14

NO22.
//此程序把一个数组复制到另外一个并且把每个元素加10打印出来
#include "stdio.h"

int add(void);

main(void)
{
int array[10],x;
int num[10];

for(x=0;x<10;x++)//给数组中每个元素赋下标相同的值
{
array[x]=x;
}
for(x=0;x<10;x++)
{
printf("\nThe array[%d] is %d",x,array[x]);//先打印一次
}
for(x=0;x<10;x++)
{
num[x]=array[x];//复制array中所有的元素到num
num[x]+=10;//给每个复制过去的元素加10
}
for(x=0;x<10;x++)
{
printf("\nAnother array[%d] is %d",x,num[x]);//打印新数组中的所有值
}
getch();
return 0;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:15

NO23.
//此程序循环读入一个数组
//然后循环打印每个元素的值和内存地址
#include "stdio.h"

#define MAX 10

int array[MAX];
int *ptr_array,ctr;//接触指针

main(void)
{
ptr_array=array;
for(ctr=0;ctr<10;ctr++)
{
printf("Input the No.%d number:",ctr);
scanf("%d",&array[ctr]);//循环读入数组中的所有值
}
for(ctr=0;ctr<10;ctr++)
{
printf("\nThe No.%d element is %d!",ctr,array[ctr]);//这里是输出所有元素的值
}//在上面一步发现了一个可爱的问题已经发在CSDN展开讨论
for(ctr=0;ctr<10;ctr++)
{
printf("\nThe address of No.%d element is %ld!",ctr,ptr_array++);//打印所有地址
}
getchar();
return 0;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|已经调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:15

NO24.
//复习一下函数调用
//此程序接受两个长度任意的数组并把他们中的所有元素相加
//把总和反馈到主函数
#include "stdio.h"

int sumarray(int a[],int b[]);

int array1[]={0,1,2,3,4};
int array2[]={0,1,2,3,4,5,6,7};

int x=0;

main(void)
{
x=sumarray(array1,array2);//注意看调用函数传递值的时候是使用数组首元素的地址
printf("The largest is %d!",x);
getch();//这里在VC下应该是getchar
return 0;
}
int sumarray(int a[],int b[])//这里不一定要和函数原型一样但是写成一样便于理解
{
int largest=0,ctr;
for(ctr=0;ctr<5;ctr++)
{
largest+=a[ctr];
}
for(ctr=0;ctr<8;ctr++)
{
largest+=b[ctr];
}
return largest;
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|TC调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: 冰血封情    时间: 2004-6-25 21:15

NO25.
//此程序复习函数调用
//程序接受两个长度相同的数组并且把对应值相加保存在第三个数组中
//打印各个过程的结果
#include "stdio.h"

void addarrays(int a[10],int b[10]);//这里可以不写那个10的

int array1[10],array2[10],num[10];

main(void)
{
int ctr1;
for(ctr1=0;ctr1<10;ctr1++)//利用循环输入两个数组的元素
{
printf("\nPlease input the %d number of array1:",ctr1);
scanf("%d",&array1[ctr1]);
}
for(ctr1=0;ctr1<10;ctr1++)
{
printf("\nPlease input the %d number of array2:",ctr1);
scanf("%d",&array2[ctr1]);
}
addarrays(array1,array2);//调用函数计算
for(ctr1=0;ctr1<10;ctr1++)
{
printf("\narray3[%d] is %d.",ctr1,num[ctr1]);
}
getch();
return 0;
}

void addarrays(int a[10],int b[10])
{
int ctr2;
for(ctr2=0;ctr2<10;ctr2++)
{
num[ctr2]=a[ctr2]+b[ctr2];//对应元素相加保存在第三个数组的对应元素中
}
for(ctr2=0;ctr2<10;ctr2++)
{
printf("\nnum[%d] is %d!",ctr2,num[ctr2]);
}
}

---------------------------------------------------------------------------------------------------
程序已经调试无错误|无警告信息|TC调试能可以用|有高手有问题请赐教|欢迎指出错误。
---------------------------------------------------------------------------------------------------

大学的能力和差距产生在是否因为学习而学习!
作者: Hoky    时间: 2004-9-21 09:37

我现在看“printf”感觉不习惯,还是习惯“cout <<”。
当初学C语言的时候老师强制让我们保存为".cpp"。
你的笔记注释真够详细的。 [s:17]
作者: 冰血封情    时间: 2004-9-21 11:46

printf cout 是完全不同的两个东西(废话)
但是我要说的和您想的不同:)
在您不了解对象的内部情况的时候可以使用cout比较好 这显示出了C++的优势 所以您只需要接口就可以了...
其实说cout是打印数据和转译其中的内容 并不准确 在C99的定义中 cout的官方解释是:将程序插入输出数据流...

承让了:)
作者: EvilOctal    时间: 2005-2-6 00:09

两段代码功能一样
复制内容到剪贴板
代码:
#include "stdio.h"

int main(void)
{
    int x,y;
    for(x=0;x<10;x++,printf("\n"))
        for(y=0;y<10;y++)
            printf("X");
        return 0;
}
复制内容到剪贴板
代码:
#include "stdio.h"

int main(void)
{
    int x,y;
    for(x=0;x<10;x++)
    {
        for(y=0;y<10;y++)
        {
            printf("X");
        }
        printf("\n");
    }
        return 0;
}

作者: EvilOctal    时间: 2005-2-6 01:52

注释是无锋之刃做的
复制内容到剪贴板
代码:
#include "stdlib.h"
#include "stdio.h"

// 前置声明
void do_heading(char *filename);

// 全局变量
int line=0, page=0;

int main(int argv, char *argc[])
{
    char buffer[256];
    FILE *fp;

    // 如果没有命令行参数,则在控制台上输入
    if(argv<2)
    {
        fprintf(stderr, "\nProper Usage is:");
        fprintf(stderr, "\n\nprint_it filename.ext\n");
        return(1);
    }

// 打开文件出错
if((fp=fopen(argc[1],"r")) == NULL)
{
    // 在标准错误台上输出信息
    fprintf(stderr, "Error opening file, %s!", argc[1]);
    // 结束程序
    return(1);
}

page=0;
line=1;
do_heading(argc[1]);

// 读出256个字符
while(fgets(buffer,256, fp)!=NULL)
{
    // 正好是55个字符的话
    if(line%55 == 0)
        do_heading(argc[1]);
}

    fprintf(stdprn, "\f");
    fclose(fp);
    return 0;
}

void do_heading(char *filename)
{
    // 页数加1
    page++;

        // 如果页数大于1,输出一个控制符
        if(page>1)
            fprintf(stdprn, "\f");

        // 输出一些信息
        fprintf(stdprn, "page: %d, %s\n\n",page, filename);
}

作者: 冰血封情    时间: 2005-2-6 21:53

复制内容到剪贴板
代码:
//Program to calculate the product of two numbers.
#include <stdio.h>

int val1, val2, val3;

int product(int x, int y);

int main( void )
{
  //Get the first number
  printf("Enter a number between 1 and 100: ");
  scanf("%d", &val1);

  //Get the second number
  printf("Enter another number between 1 and 100: ");
  scanf("%d", &val2);

  //Calculate and display the product
  val3 = product(val1, val2);
  printf ("%d times %d = %d\n", val1, val2, val3);

  return 0;
}

//Function returns the product of the two values provided
int product(int x, int y)
{
   return (x * y);
}
复制内容到剪贴板
代码:
//Program to calculate the product of two numbers.
#include <stdio.h>


int product(int x, int y);

int main(void)
{
    int a1=0, a2=0, a3=0;

    printf("Please input a number between 1 and 100: ");
    scanf("%d",&a1);

    printf("Please input another number between 1 and 100: ");
    scanf("%d",&a2);

    a3 = product(a1, a2);
    printf("%d times %d is %d\n", a1, a2, a3);

    return 0;
}

int product(int x, int y)
{
    return(x * y);
}

作者: EvilOctal    时间: 2005-2-7 01:05

子函数练习
复制内容到剪贴板
代码:
#include <stdio.h>

void display_line(void);

int main(void)
{
    display_line();
    printf("I hate this word.\n");
    display_line();

    return 0;
}

//print asterisk line fucntion
void display_line(void)
{
    int count;
    for(count=0;count<30;count++)
    {
        printf("*");
    }

    printf("\n");
}

作者: 冰血封情    时间: 2005-2-7 02:04

strlen
复制内容到剪贴板
代码:
#include <stdio.h>
#include <string.h>

int main(void)
{
    char buffer[256];

    printf("Enter your name and press <Enter>:\n");
    gets( buffer );

    printf("\nYour name has %d character and spaces!", strlen(buffer));

    return 0;
}
复制内容到剪贴板
代码:
#include <stdio.h>
#include <string.h>

int main(void)
{
    char *string = "Fuck you gliet!";
    printf("%d\n", strlen(string));

    return 0;
}

作者: 冰血封情    时间: 2005-2-7 04:10

学习到变量和常量存储信息的地方
下面的程序我加了注释 如果回头来自己看不懂是什么功能 那就去死
复制内容到剪贴板
代码:
//demonstrates variables and constants
#include <stdio.h>

//define a constant to convert from pounds to grams
#define GRAMS_PER_POUND 454

//define a constant for the start of the next century
const int TARGET_YEAR=2010;


int main(void)
{
    //declare the needed variables
    long weight_in_grams, weight_in_pounds;
    int year_of_birth, age_in_2010;

    //input data for user
    printf("Enter your weight in pounds: ");
    scanf("%d", &weight_in_grams);
    printf("\nEnter your year of birth: ");
    scanf("%d", &year_of_birth);

    //perform conversions

    weight_in_grams = weight_in_pounds * GRAMS_PER_POUND;
    age_in_2010 = TARGET_YEAR - year_of_birth;

    //display results on the screen

    printf("\nYour weight in grams = %ld", weight_in_grams);
    printf("\nIn 2010 you will be %d years old.\n", age_in_2010);

    return 0;
}

作者: 冰血封情    时间: 2005-2-8 05:14

等会后面有个程序要想看懂 就必须要一些前置知识 其中有time和srand两个函数我不是很懂 找了资料
time函数
time_t time(time_t *thetime);
功能是取得系统的时间 需要包含头文件#include <time.h>
thetime:指向time_t变量的可选指针 在这个变量中存放当前的日期和时间 如果是NULL着忽略 代码举例如下
复制内容到剪贴板
代码:
#include <time.h>
#include <stdio.h>
#incude <dos.h>

int main(void)
{
       time_t t;
       time(&t);
       printf("The number of seconds since January 1, 1970 is %ld", t);
       return 0;
}
srand函数 原型
void srand(unsigned seed);
它的功能是 用来初始化随机数发生器 以便让随机数发生器产生可以预测的随即序列(nnd这JB叫什么解释呀)
头文件是#include <stdlib.h>
参数说明
seed是无符号整数 指明随机数序列的最小起点 注意是没有返回值的 下面来个演示程序
复制内容到剪贴板
代码:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(void)
{
  int i;
  time_t t;
  srand((unsigned) time(&t));
  printf("Three random numbers from 0 to 99:");

  for(i=0;i<3;i++)
  printf("%d\n", rand()%100);
  return 0;
}
好 前置知识解决了 下面来看一个猜数字游戏 本来这个游戏是只要求能输入运行查看结果的 很不幸 我读懂了 比第一天有进步 第一天的程序是无锋帮我分析的
复制内容到剪贴板
代码:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define NO    0
#define YES   1

int main(void)
{
    int guess_value = -1;
    //要猜测的数字
    int number;
    //猜测次数
    int nbr_of_guesses;
    //这里必须要先等于NO 以便下面的while可以继续
    int done = NO;

    printf("\n\nGetting a random number......\n");

    //嘿嘿 上面的那个就是这里了
    srand( (unsigned) time( NULL ) );
    //取随机数字让你猜的那个
    number = rand();

    //猜测次数
    nbr_of_guesses = 0;
    while (done == NO)
    {
        printf("\nPick a number between 0 and %d>", RAND_MAX);
            scanf("%d", &guess_value);

        nbr_of_guesses++;
        //这里就是本单元学的if...else结构 用来判断你猜对没
        if ( number == guess_value)
        {
            done = YES;
        }
        else if(number < guess_value)
        {
            printf("\nYou guessed high!");
        }
        else
        {
            printf("\nYou guessed low!");
        }
    }

    printf("\nCongratulateions! You guessed right in %d Guesses!", nbr_of_guesses);
    printf("\nThe number was %d\n\n",number);


    return 0;
}

作者: 冰血封情    时间: 2005-2-8 08:03

简单的递归调用
复制内容到剪贴板
代码:
# include <stdio.h>

unsigned int f, x;
unsigned int factorial(unsigned int a);

int main(void)
{
    puts("Enter an integer value between 1 and 8: ");
    scanf("%d", &x);

    if(x>8||x<1)
    {
        printf("Only values from 1 to 8 are acceptable!");
    }
    else
    {
        f = factorial(x);
        printf("%u factorial equals %u\n", x, f);
    }


    return 0;
}

unsigned int factorial(unsigned int a)
{
    if(a == 1)
        return 1;
    else
    {
        a*=factorial(a-1);
        return a;
    }
}

作者: 冰血封情    时间: 2005-2-8 08:21

使用多条return语句的作业
原来的例子
复制内容到剪贴板
代码:
//Demonstrates using multiple return statements in a function.

#include <stdio.h>

int x, y, z;

int larger_of( int a, int b);

int main( void )
{
   puts("Enter two different integer values: ");
   scanf("%d%d", &x, &y);

   z = larger_of(x,y);

   printf("\nThe larger value is %d.", z);

  return 0;
}

int larger_of( int a, int b)
{
   if (a > b)
      return a;
   else
      return b;
}
要求子函数中只包含一条return 如下
复制内容到剪贴板
代码:
//Demonstrates using multiple return statements in a function.

#include <stdio.h>

int x, y, z;

int larger_of( int a, int b);

int main( void )
{
   puts("Enter two different integer values: ");
   scanf("%d,%d", &x, &y);

   z = larger_of(x,y);

   printf("\nThe larger value is %d.", z);

  return 0;
}

int larger_of( int a, int b)
{
   int re;
    re=a>b?a:b;

    return re;
}

作者: 冰血封情    时间: 2005-2-9 02:57

求数组里的最大值 最小值 输入0终止接收
复制内容到剪贴板
代码:
#include <stdio.h>

#define MAX 100

int array[MAX];
int count = -1, maximum, minimum, num_entered, temp;

int main(void)
{
    puts("Enter interger values one per line.");
    puts("Enter 0 when finished.");

    //input the values
    do
    {
        scanf("%d", &temp);
        array[++count] = temp;
    }while ( count < (MAX-1) && temp !=0 );

    num_entered = count;

    //find the largest and smallest

    maximum = -32000;
    minimum = 32000;

    for ( count = 0; count <= num_entered && array[count] != 0; count++ )
    {
        if ( array[count] > maximum )
            maximum = array[count];

        if ( array[count] < minimum )
            minimum = array[count];
    }

    printf("\nThe maximum value is %d", maximum);
    printf("\nThe minimum value is %d\n", minimum);

    return 0;
}

作者: xiaohui_82    时间: 2005-3-2 14:48

成绩管理系统
复制内容到剪贴板
代码:

#include<stdio.h>      /* head file*/
#include<stdlib.h>
#include<graphics.h>
#include<conio.h>
#include<bios.h>
#include<time.h>
#define LEFT  70      /* the cursor&#39;s place */
#define RIGHT  78
#define UP    72
#define DOWN  80
#define ESC  283
#define ENTER  7181
#define F10 17408      /* enter menu */
#define F1 15104       /* help*/
#define len sizeof(Fname)

long a_sta[50];       /*answer stack*/
union key           /*use bioskey*/
{char sym[2];
int  sym2;
}KEY,Choose,ans;
union inkey
{int c;
char ch[2];
}sc,key;
static int bx=45,by=5,ex,ey;    /*cursor&#39;s place*/
FILE *fp,*fp2;             /*FILE pointer*/
char filename[20];
int wrong[50];             /*Wrong answer&#39;s number*/
struct fname              /*student&#39;s information*/
{
char filename[20];
char name[20];
int  level;
int  score;
struct fname *next;
}*message,*head;
typedef struct fname Fname;


void choose_menu(void);       /* used funtion*/
void place(int ,int );
void re(int,int);
void Screen(void);
void SFile(void);
void Stest(void);
void Scheck(void);
void choose_act(void);
char *save(void);
void load(void);
void lv1(int,int,int,int,int,int);
void lv2(int,int,int,int,int,int);
void lv3(void);
int ans1(int,int,int,int,int,int,int,int);
void fangkuai(void);
char *intext(int,int);
void loadfile(void);
Fname *save_name(Fname*);
Fname *load_name(Fname*);
Fname *input(Fname*);
void print_list(Fname*);
Fname *sread(Fname*);
void Sl(void);
void pw(void);
void sename(void);
void selv(void);
void sesc(void);
void menu(void);
void Last(void);
void help(void);

void main()
{int i,gdr=DETECT,gmo;
head=(Fname*)malloc(len);
head=NULL;
  {if((fp2=fopen("wuxi.txt","rb"))!=NULL)  /*information file*/
   head=load_name(head);
   fclose(fp);
  }
initgraph(&gdr,&gmo,"");
menu();            /* the first screen*/
if(key.c==F1)help();
cleardevice();
Screen();
setbkcolor(BLUE);
outtextxy(15,449,"Press F10 into menu");
Choose.sym2=bioskey(0);
while(Choose.sym2!=ESC)
  { if(Choose.sym2==F10)
    choose_menu();
    Choose.sym2=bioskey(0);
   }
closegraph();
}
void choose_menu()    /*choose what you want to choose*/
{setcolor(WHITE);
place(bx,by);
KEY.sym2=bioskey(0);
while(KEY.sym2!=ESC)
  {re(bx,by);
   if(KEY.sym[0]==0)
     switch(KEY.sym[1])
        {case 0x4b: bx=bx-208;if(bx<=0)bx=461;break;
         case 0x4d: bx=bx+208;if(bx>=669)bx=45;break;
         }
   else
     if(KEY.sym2==ENTER)
      switch(bx)
         {case 45:
             Screen();
             SFile();
             place(bx,by);
             choose_act();
             break;
        case 253:
             Screen();
             Stest();
             place(bx,by);
             choose_act();
             break;
        case 461:
             Screen();
             Scheck();
             place(bx,by);
             choose_act();
             break;
         }
    place(bx,by);
    KEY.sym2=bioskey(0);
    Screen();
  }
}
void place(int a0,int a1)             /* cover the son_menu*/
{ setfillstyle(SOLID_FILL,WHITE);
  bar(a0,a1,a0+60,a1+15);
  switch(a0)
    {case 45:
        setcolor(RED);
        outtextxy(50,10,"File");
        setfillstyle(SOLID_FILL,BLUE);
        bar(11,449,620,459);
        setcolor(YELLOW);
        outtextxy(15,449,"Press ENTER into FILE,Press ESC to exit");
        break;
    case 253:setcolor(RED);
         outtextxy(258,10,"Test");
         setfillstyle(SOLID_FILL,BLUE);
         bar(11,449,620,459);
         setcolor(YELLOW);
         outtextxy(15,449,"Press ENTER into LEVEL,Press ESC to exit");
         break;
    case 461:
         setcolor(RED);
         outtextxy(466,10,"Search");
         setfillstyle(SOLID_FILL,BLUE);
         bar(11,449,620,459);
         setcolor(YELLOW);
         outtextxy(15,449,"Press ENTER to SEARCH,Press ESC to exit");
         break;
    }
}
  void re(int a0,int a1)       /*cover the main_menu*/
{ setfillstyle(EMPTY_FILL,RED);
  setcolor(YELLOW);
  bar(a0,a1,a0+80,a1+15);
   outtextxy(50,10,"File");
   outtextxy(258,10,"Test");
   outtextxy(466,10,"Search");
}
void Screen()
{
setfillstyle(SOLID_FILL,BLUE);
bar(1,1,679,479);
setcolor(LIGHTCYAN);
rectangle(10,1,629,25);
rectangle(10,30,629,469);
line(10,439,629,439);
setcolor(YELLOW);
outtextxy(50,10,"File");
outtextxy(258,10,"Test");
outtextxy(466,10,"Search");
}
  void SFile()
{setfillstyle(SOLID_FILL,WHITE);
  bar(15,20,150,180);
  setcolor(BLACK);
  rectangle(20,30,140,170);
  outtextxy(35,50,"Load");
  outtextxy(35,90,"Help");
  outtextxy(35,130,"Exit");
}
  void Stest()
{setfillstyle(SOLID_FILL,WHITE);
  bar(225,20,350,180);
  setcolor(BLACK);
  rectangle(230,30,340,170);
  outtextxy(245,50,"LV1");
  outtextxy(245,90,"LV2");
  outtextxy(245,130,"LV3");
}
  void Scheck()
{setfillstyle(SOLID_FILL,WHITE);
  bar(430,20,545,180);
  setcolor(BLACK);
  rectangle(440,30,535,170);
  outtextxy(455,50,"By name");
  outtextxy(455,90,"By lv");
  outtextxy(455,130,"By score");
}
  void choose_act()
{ Fname *p;
  ex=bx-15;
  ey=by+35;
  Choose.sym2=bioskey(0);
  while(Choose.sym2!=ESC)
    { setfillstyle(SOLID_FILL,WHITE);
    bar(ex,ey,ex+80,ey+20);
    switch(bx)
       { case 45:SFile();break;
        case 253:Stest();break;
        case 461:Scheck();break;
        }
    setcolor(RED);
    if(!Choose.sym[0]){
      switch(Choose.sym[1])
        {case UP:  ey-=40;if(ey<40)ey=120;break;
        case DOWN:ey+=40;if(ey>120)ey=40;break;
        }

     setfillstyle(SOLID_FILL,BLACK);
     bar(ex,ey,ex+80,ey+20);
     switch(ex)
     { case 30:
          switch(ey)
            {
            case 40:outtextxy(35,50,"Load");
                    setfillstyle(SOLID_FILL,BLUE);
                bar(11,449,620,459);
                    setcolor(YELLOW);
                outtextxy(15,449,"Press ENTER into Open file,Press UP\\DOWN to choose,Press ESC to exit");
                break;
            case 80:outtextxy(35,90,"Help");
                    setfillstyle(SOLID_FILL,BLUE);
                bar(11,449,620,459);
                    setcolor(YELLOW);
                outtextxy(15,449,"Press ENTER into Save file,Press UP\\DOWN to choose,Press ESC to exit");
                break;
            case 120:outtextxy(35,130,"Exit");
                     setfillstyle(SOLID_FILL,BLUE);
                 bar(11,449,620,459);
                     setcolor(YELLOW);
                 outtextxy(15,449,"Press ENTER into Exit dos,Press UP\\DOWN to choose,Press ESC to exit");
                 break;
            }
           break;
       case 238:
          switch(ey)
            {
            case 40:outtextxy(245,50,"LV1");
                setfillstyle(SOLID_FILL,BLUE);
                bar(11,449,620,459);
                    setcolor(YELLOW);
                outtextxy(15,449,"Press ENTER into LV1,Press UP\\DOWN to choose,Press ESC to exit");
                break;
            case 80:outtextxy(245,90,"LV2");
                    setfillstyle(SOLID_FILL,BLUE);
                bar(11,449,620,459);
                    setcolor(YELLOW);
                outtextxy(15,449,"Press ENTER into LV2,Press UP\\DOWN to choose,Press ESC to exit");
                break;
            case 120:outtextxy(245,130,"LV3");
                     setfillstyle(SOLID_FILL,BLUE);
                 bar(11,449,620,459);
                     setcolor(YELLOW);
                 outtextxy(15,449,"Press ENTER into LV3,Press UP\\DOWN to choose,Press ESC to exit");
                 break;
            }
            break;
       case 446:
          switch(ey)
            {
            case 40:outtextxy(455,50,"By name");
                    setfillstyle(SOLID_FILL,BLUE);
                bar(11,449,620,459);
                    setcolor(YELLOW);
                outtextxy(15,449,"Press ENTER into Justice,Press UP\\DOWN to choose,Press ESC to exit");
                break;
            case 80:outtextxy(455,90,"By lv");
                    setfillstyle(SOLID_FILL,BLUE);
                bar(11,449,620,459);
                    setcolor(YELLOW);
                outtextxy(15,449,"Press ENTER into Return test,Press UP\\DOWN to choose,Press ESC to exit");
                break;
            case 120:outtextxy(455,130,"By score");
                 setfillstyle(SOLID_FILL,BLUE);
                 bar(11,449,620,459);
                     setcolor(YELLOW);
                 outtextxy(15,449,"Press ENTER into Exit,Press UP\\DOWN to choose,Press ESC to exit");
                 break;
            }
            break;
         }
        }
      else if(Choose.sym2==ENTER)
        {
         switch(ex)
            {  case 30:
                switch(ey)
                 {case 40: load();break;
                  case 80: help();head=save_name(head);break;
                  case 120:Last();exit(0);break;
                 }
                break;
            case 238:
                 switch(ey)
                  {
                  case 40:head=input(head);p=sread(head);p->level=1;Screen();lv1(20,40,50,125,40,0);p->score+=ans1(95,40,50,125,40,4,0,2);save();head=save_name(head);
                      Screen(); pw();getch();choose_menu();break;
                  case 80:head=input(head);p=sread(head);p->level=2;Screen();lv2(20,40,20,150,70,0);p->score+=ans1(125,40,20,150,70,3,0,5);save();head=save_name(head);
                      Screen(); pw();getch();choose_menu();break;
                  case 120:head=input(head);p=sread(head);p->level=3;Screen();lv3();p->score+=ans1(90,35,20,125,20,4,0,1);p->score+=ans1(125,115,20,150,20,3,20,2);p->score+=ans1(250,215,10,1,20,0,40,4);save();head=save_name(head);
                       Screen();pw();getch();choose_menu();
                  }
                 break;
             case 446:
                switch(ey)
                 {
                  case 40:sename();break;
                  case 80:selv();break;
                  case 120: sesc(); break;
                 }
                break;
            }
        }
     Choose.sym2=bioskey(0);
     }
   Screen();
}
char *save(void)
{
int i, j;
strcpy(filename,sread(head)->filename);
if((fp=fopen(filename,"wb"))==NULL){
   outtext("cannot open this file!");
   choose_menu();
  }
outtextxy(260,449,"waiting....");
  for(i=1;i<=470;i++){
    for(j=1;j<=635;j++){
    fputc(getpixel(j,i),fp);
    }
    }
  fclose(fp);
  setfillstyle(SOLID_FILL,BLUE);
  bar(11,449,620,459);
  outtextxy(260,449,"save over!");
  setfillstyle(SOLID_FILL,BLUE);
  bar(15,471,639,479);
  return filename;
}

void load(void)
{
  char *choice=" ";
  fangkuai();
  outtextxy(210,270,"1.load filename");
  outtextxy(210,300,"2.load file");
  outtextxy(210,330,"  input your choice:");
  strcpy(choice,intext(370,330));
  getch();
  setfillstyle(SOLID_FILL,BLUE);
  bar(200,200,500,400);
  switch(*choice)
   {case &#39;1&#39;: head=load_name(head);print_list(head);break;
    case &#39;2&#39;: loadfile(); break;
    default:  return;
   }
  choose_menu();
}
void loadfile(void)
{ int i,j;
  fangkuai();
  outtextxy(210,300,"input filename:");
  strcpy(filename,intext(350,300));
  if((fp=fopen(filename,"rb"))==NULL){
     outtext("Cannot open this file!");
     setfillstyle(SOLID_FILL,BLUE);
     bar(11,449,620,459);
     choose_menu();
    }
  setfillstyle(SOLID_FILL,BLUE);
  bar(11,449,620,459);
  outtextxy(260,449,"loading.....");
  for(i=1;i<=470;i++){
    for(j=1;j<=635;j++){
     putpixel(j,i,fgetc(fp));
    }
  }
  getch();
  fclose(fp);
}

void lv1(int x,int y,int length,int dx,int dy,int sta)
{
int first,second,mid[4],ans,t,k;
int count;
time_t ti;
char str1[25],str2[25];
int cx=x,cy=y;
srand((unsigned)time(&ti));
for(count=0;count<length;count++)
  {
  first=rand()%100+1;
  second=rand()%100+1;
  if(first<second){t=first;first=second;second=t;}
  ans=rand()%4+1;
  itoa(first,str1,10);
  itoa(second,str2,10);
  strcat(str2,"=");
  switch(ans)
    {case 1: a_sta[count+sta]=first+second; outtextxy(cx+10,cy,str1);outtextxy(cx+35,cy,"+");outtextxy(cx+50,cy,str2);break;
    case 2: a_sta[count+sta]=first-second; outtextxy(cx+10,cy,str1);outtextxy(cx+35,cy,"-");outtextxy(cx+50,cy,str2);break;
    case 3: a_sta[count+sta]=first*second; outtextxy(cx+10,cy,str1);outtextxy(cx+35,cy,"*");outtextxy(cx+50,cy,str2);break;
    case 4: a_sta[count+sta]=first/second; outtextxy(cx+10,cy,str1);outtextxy(cx+35,cy,"/");outtextxy(cx+50,cy,str2);break;
    }
  cx+=dx;
  if(cx>x+4*dx){cy+=dy;cx=x;}
  }
}

void lv2(int x,int y,int length,int dx,int dy,int sta)
{int num;
long a,b,c,d,t,op1,op2;
int cx=x,cy=y;
char str1[25],str2[25],str3[25];
static time_t ti;
srand((unsigned)time(&ti));
for(num=0;num<length;num++)
  {  a=rand()%100+1;
    b=rand()%100+1;
    c=rand()%100+1;
    if(a<b){t=a;a=b;b=t;}
    op1=rand()%4+1;
    itoa(a,str1,10);
    itoa(b,str2,10);
    switch(op1)
     {case 1: d=a+b;outtextxy(cx,cy,str1);outtextxy(cx+25,cy,"+");outtextxy(cx+40,cy,str2);break;
    case 2: d=a-b;outtextxy(cx,cy,str1);outtextxy(cx+25,cy,"-");outtextxy(cx+40,cy,str2);break;
    case 3: d=a*b;outtextxy(cx,cy,str1);outtextxy(cx+25,cy,"*");outtextxy(cx+40,cy,str2);break;
    case 4: d=a/b;outtextxy(cx,cy,str1);outtextxy(cx+25,cy,"/");outtextxy(cx+40,cy,str2);break;
     }
op2=rand()%4+1;
itoa(c,str3,10);
  switch(op2)
  {case 1: a_sta[num+sta]=d+c;outtextxy(cx+65,cy,"+");outtextxy(cx+80,cy,str3);outtextxy(cx+100,cy,"=");break;
  case 2: a_sta[num+sta]=d-c;outtextxy(cx+65,cy,"-");outtextxy(cx+80,cy,str3);outtextxy(cx+100,cy,"=");break;
  case 3: a_sta[num+sta]=d*c;outtextxy(cx+65,cy,"*");outtextxy(cx+80,cy,str3);outtextxy(cx+100,cy,"=");break;
  case 4: a_sta[num+sta]=d/c;outtextxy(cx+65,cy,"/");outtextxy(cx+80,cy,str3);outtextxy(cx+100,cy,"=");break;
  }
  if((op1==1||op1==2)&&(op2==3||op2==4)){outtextxy(cx-5,cy,"(");outtextxy(cx+60,cy,")");}
  cx+=dx; if(cx>x+3*dx){cy+=dy;cx=x;}
  }
}
void lv3()
{long a0;
long n,d,c,t1,t2;
int x=15,y=215;
char str[25];
lv1(15,35,20,125,20,0);
lv2(15,115,20,150,20,20);
for(t1=0;t1<10;t1++)
  {
  c=rand()%2+1;
  if(c==1){a0=rand()%9+1;d=rand()%5+1;n=rand()%99+50;}
    else {a0=rand()%3+1;d=rand()%2+1;n=rand()%12+10;}
  a_sta[t1+40]=0;
  if(c==1)
  for(t2=0;t2<n;t2++)
    {a_sta[t1+40]+=a0;
    ltoa(a0,str,10);
    a0=a0+d;
    if(t2==0||t2==1||t2==2)
     {outtextxy(x,y,str);
    outtextxy(x+15,y,"+");
     }
    if(t2==2)outtextxy(x+25,y,"...");
    if(t2==n-1){outtextxy(x+40,y,"+");outtextxy(x+55,y,str);outtextxy(x+120,y,"=");}
    if(t2==0||t2==1||t2==2)x+=20;
    }
  else
  for(t2=0;t2<n;t2++)
    {a_sta[t1+40]+=a0;
    ltoa(a0,str,10);
    a0=a0*d;
    if(t2==0||t2==1||t2==2)
     {outtextxy(x,y,str);
    outtextxy(x+15,y,"+");
     }
    if(t2==2)outtextxy(x+25,y,"...");
    if(t2==n-1){outtextxy(x+40,y,"+");outtextxy(x+55,y,str);outtextxy(x+120,y,"=");}
    if(t2==0||t2==1||t2==2)x+=20;
    }
  x=15;
  y+=20;
  }

}
int ans1(int x,int y,int length,int dx,int dy,int m,int sta,int ds)
{
int num,ax=x,ay=y,i=0,score=0,j=sta;
long anst=0;
char *ch1,*ch/*,daan[25]*/;
for(num=0;num<length;num++)
  { ch1=" ";
    ch="                                                                                                                                                          ";
  /*  ltoa(a_sta[num+sta],daan,10);*/
    moveto(ax,ay);
  /*  outtextxy(ax,ay,daan);*/ /* you can see the answer*/
    while(ch[i++]!=&#39;\r&#39;)
    {
    ans.sym2=bioskey(0);
    if(ans.sym2==F10)choose_menu();
    ch1[0]=ans.sym[0];
    anst=atol(ch1)+anst*10;
    outtext(ch1);
    ch[i]=ch1[0];
     }
    ch[--i]=&#39;\0&#39;;
    anst/=10;
    if(a_sta[num+sta]<0)anst=-anst;
    if(anst==a_sta[num+sta])score=score+ds;
    else {wrong[j++]=num+sta+1;
        }
    ax+=dx;
    if(ax>x+m*dx){ax=x;ay+=dy;}
    anst=0;
    }
  return score;
}
void pw(void)
{Fname *p;
int i,x=350,y=250;
char str[25],str1[25];
setfillstyle(SOLID_FILL,BLUE);
bar(200,200,500,400);
p=sread(head);
itoa(p->score,str,10);
fangkuai();
setcolor(RED);
outtextxy(210,230,"SCORE:");
outtextxy(350,230,str);
outtextxy(230,250,"WRONG:");
  for(i=0;i<50;i++)
  {if(wrong[i]!=0)
    {itoa(wrong[i],str1,10);
    outtextxy(x,y,str1);
    x+=40;
    if(x>450){y+=20;x=230;}
    }
  }
getch();
setfillstyle(SOLID_FILL,BLUE);
bar(200,200,500,430);
setcolor(YELLOW);
}
void fangkuai(void)
{int i,j;
for(j=200;j<=400;j++)
  for(i=200;i<=500;i++)
  putpixel(i,j,15^getpixel(i,j));
}
char *intext(int x,int y)
{char *ch,*ch1;
int i=0;
moveto(x,y);
ch1=" ";
ch="             ";
  do
   {
    sc.c=bioskey(0);
    ch1[0]=sc.ch[0];
    outtext(ch1);
    ch[i]=ch1[0];
   }while(!(ch[i++]==&#39;\r&#39;));
  ch[--i]=&#39;\0&#39;;
  return(ch);
}

  Fname *save_name(Fname *head)
{
  Fname *info;
  if((fp2=fopen("wuxi.txt","wb"))==NULL)
    {outtext("cannot open this file\n");
     choose_menu();
    }
  else
   info=head;
   while(info!=NULL)
    { if((fp=fopen(info->filename,"rb"))!=NULL)
     fwrite(info,sizeof(Fname),1,fp2);
     info=info->next;
    }
  fclose(fp);
  fclose(fp2);
  return(head);
}
Fname *load_name(Fname *head)
{
  Fname *last,*info;
  if((fp=fopen("wuxi.txt","rb"))==NULL){
   outtext("Cannot open file.\n");
   choose_menu();
      }
  head=(Fname*)malloc(len);
  fread(head,len,1,fp);
  last=head;
  while(!feof(fp))
  { info=(Fname *)malloc(len);
   if(!info){
   printf("Out of Memory");
   }
   if(1!=fread(info,len,1,fp)) break;
   last->next=info;
   last=info;
  }
  fclose(fp);
  return(head);
}
Fname *input(Fname *ht)
{
Fname *p1,*p2,*c;
char com[20];
setfillstyle(SOLID_FILL,BLUE);
bar(200,200,500,400);
fangkuai();
outtextxy(210,210,"input filename:");
  if(ht!=NULL)
  {
   p1=(Fname*)malloc(len);
   p2=(Fname*)malloc(len);
   p2=ht;
   while(p2->next!=NULL)
   p2=p2->next;
   strcpy(com,intext(350,210));
   c=ht;
   while(c!=NULL)
    {
     if(strcmp(c->filename,com)==0){outtext("REPEATED NAME");getch();return input(ht);}
     else c=c->next;
    }
   if((fp=fopen(com,"wb"))==NULL){outtextxy(220,240,"Cannot open this file");getch();return input(ht);}
  else{
   strcpy(p1->filename,com);
   outtextxy(210,350,"Input name:");
   strcpy(p1->name,intext(350,350));
   p1->score=0;
   p1->next=NULL;
   p2->next=p1;
   p2=p1->next;
     }
  }
else
  {ht=(Fname*)malloc(len);
   strcpy(com,intext(350,210));
    if((fp=fopen(com,"wb"))==NULL){outtextxy(220,240,"Cannot open this file");getch();return input(ht);}
  else{
     strcpy(ht->filename,com);
     outtextxy(210,350,"Input name:");
     strcpy(ht->name,intext(350,350));
     ht->score=0;
     ht->next=NULL;
    }
  }
getch();
setfillstyle(SOLID_FILL,BLUE);
bar(200,200,500,400);
return(ht);
}
void print_list(Fname *ht)
{
Fname *p;
int i=60,j=40;
char str[25];
Sl();
p=ht;
settextstyle(0,0,1);
while(p!=NULL)
  {itoa(p->score,str,10);
   outtextxy(i,j,p->filename);
   outtextxy(i+150,j,p->name);
   switch(p->level)
    {case 1: outtextxy(i+300,j,"lv1");break;
     case 2: outtextxy(i+300,j,"lv2");break;
     case 3: outtextxy(i+300,j,"lv3");break;
    }
   outtextxy(i+450,j,str);
   p=p->next;
   j=j+10;
  }
getch();
settextstyle(0,0,0);
Screen();
choose_menu();
}
void Sl(void)
{
setfillstyle(SOLID_FILL,YELLOW);
bar(0,0,639,479);
setlinestyle(0,0,1);
settextstyle(0,0,2);
outtextxy(150,2,"-----INFORMATION----");
outtextxy(130,430,"--PRESS ANY KEY TO RETURN--");
rectangle(50,25,589,419);
settextstyle(0,0,1);
outtextxy(60,30,"FILENAME");
outtextxy(210,30,"NAME");
outtextxy(360,30,"LEVEL");
outtextxy(510,30,"SCORE");
line(50,38,589,38);
setlinestyle(0,0,3);
}
Fname *sread(Fname *head)
{Fname *last,*info;
info=head;
  while(info!=NULL)
  {last=info;
   info=info->next;
  }
  return(last);
}
void sename(void)
{char str1[25],str[25];
int  i=60,j=40;
Fname *p;
fangkuai();
outtextxy(210,300,"input name:");
strcpy(str1,intext(300,300));
Sl();
p=head;
settextstyle(0,0,1);
while(p!=NULL)
  {if(strcmp(str1,p->name)==0)
    {itoa(p->score,str,10);
     outtextxy(i,j,p->filename);
     outtextxy(i+150,j,p->name);
    switch(p->level)
     {case 1: outtextxy(i+300,j,"lv1");break;
      case 2: outtextxy(i+300,j,"lv2");break;
      case 3: outtextxy(i+300,j,"lv3");break;
     }
    outtextxy(i+450,j,str);
    j=j+10;
    }
   p=p->next;
  }
if(j==40)outtextxy(i,j,"CANNOT FIND THE NAME!");
getch();
settextstyle(0,0,0);
Screen();
choose_menu();
}
  void selv(void)
{char str1[25],str[25];
int  i=60,j=40,lv;
Fname *p;
fangkuai();
outtextxy(210,300,"input level:");
strcpy(str1,intext(300,300));
lv=atoi(str1);
Sl();
p=head;
settextstyle(0,0,1);
while(p!=NULL)
  {if(p->level==lv)
    {itoa(p->score,str,10);
     outtextxy(i,j,p->filename);
     outtextxy(i+150,j,p->name);
    switch(p->level)
     {case 1: outtextxy(i+300,j,"lv1");break;
      case 2: outtextxy(i+300,j,"lv2");break;
      case 3: outtextxy(i+300,j,"lv3");break;
     }
    outtextxy(i+450,j,str);
    j=j+10;
    }
   p=p->next;
  }
if(j==40)outtextxy(i,j,"CANNOT FIND THE LEVEL!");
getch();
settextstyle(0,0,0);
Screen();
choose_menu();
}
void sesc(void)
{char str1[25],str[25];
int  i=60,j=40,score;
Fname *p;
fangkuai();
outtextxy(210,300,"input score:");
strcpy(str1,intext(300,300));
score=atoi(str1);
Sl();
p=head;
settextstyle(0,0,1);
while(p!=NULL)
  {if(p->score==score)
    {itoa(p->score,str,10);
     outtextxy(i,j,p->filename);
     outtextxy(i+150,j,p->name);
    switch(p->level)
     {case 1: outtextxy(i+300,j,"lv1");break;
      case 2: outtextxy(i+300,j,"lv2");break;
      case 3: outtextxy(i+300,j,"lv3");break;
     }
    outtextxy(i+450,j,str);
    j=j+10;
    }
   p=p->next;
  }
if(j==40)outtextxy(i,j,"CANNOT FIND THE SCORE!");
getch();
settextstyle(0,0,0);
Screen();
choose_menu();
}
void menu(void)
{char subject[28]="Arithmatic System",
    name[28]="Wu XiaoHui",
    class[28]="Computer 4",
    no[28]="2001374424",
    help[40]="<Press F1 into help>";
time_t ti;
srand((unsigned)time(&ti));
setbkcolor(BLUE);
{setcolor(LIGHTGREEN);
  setlinestyle(SOLID_LINE,0,3);
  rectangle(80,85,530,150);
}
settextstyle(0,0,1);
setcolor(YELLOW);
outtextxy(150,300,"Designer:");
outtextxy(300,300,name);
outtextxy(150,320,"Class:");
outtextxy(300,320,class);
outtextxy(150,340,"Number:");
outtextxy(300,340,no);
outtextxy(200,460,help);
  while(!kbhit())
{
  setcolor(rand()%14+1);
  settextstyle(4,0,6);
  outtextxy(100,90,subject);
  delay(100000);
  }
key.c=bioskey(0);
settextstyle(0,0,1);
}
void Last(void)
{char bye[20]="THANK YOU",
    good[20]="VISIT MY SYSTEM";
int r;
cleardevice();
setbkcolor(BLUE);
settextstyle(1,0,7);
setcolor(YELLOW);
outtextxy(150,80,bye);
outtextxy(50,200,good);
rectangle(20,20,629,469);
sleep(1);
}
void help(void)
{int i,a,b;
setfillstyle(SOLID_FILL,CYAN);
bar(0,0,639,479);
setlinestyle(0,0,1);
settextstyle(0,0,2);
setcolor(RED);
outtextxy(150,2,"-----INFORMATION----");
outtextxy(130,430,"--PRESS ANY KEY TO RETURN--");
rectangle(50,25,589,419);
settextstyle(0,0,1);
outtextxy(100,50,"1.Press F10 ,you can choose the menu.");
outtextxy(100,70,"2.Press \30 or \31 to choose son_menu.");
outtextxy(100,90,"3.Choose File ,you can see the filename or test paper.");
outtextxy(100,110,"4.If you finish the paper ,please waiting for saving.");
outtextxy(100,130,"5.Don&#39;t type any other nonscene,or it will run wrong");
outtextxy(100,150,"6.Something you can see in the menu&#39;s underside");
outtextxy(100,170,"7.Before doing the paper,you must input your imformation.");
setlinestyle(0,0,3);
a=320;
b=320;
while(!kbhit())
  {a=(a++)%639;
  if(a==639)a=321;
  b--;
  if(b==0)b=319;
  for(i=0;i<=479;i++)
    {putpixel(a,i,15^getpixel(a,i));
    putpixel(b,i,15^getpixel(b,i));
    }
  }
settextstyle(0,0,1);
Screen();
choose_menu();
}

作者: xiaohui_82    时间: 2005-3-2 14:50

俄罗斯方块简单C语言版
复制内容到剪贴板
代码:
#include<graphics.h>
int score,speed;
int dx=270,dy=151,tag=1;
main()
{
int gd=DETECT,gm;
int press,fag1,fag2,fag3;
int i,j;
char str[10];
initgraph(&gd,&gm,"C:\\turboc2");
score=0;
speed=30000;
cleardevice();
inicrack();
getch();
cleardevice();
screen();
setcolor(RED);
sprintf(str,"%d",score);
outtextxy(92,205,"LEVER 1");
outtextxy(255,120,str);
fag2=1;
while(1)
  {
   if(dy<165)
      {
      fag1=fag2;
      fag2=rand()%7+1;
      setfillstyle(SOLID_FILL,GREEN);
      bar(370,170,398,198);
      switch(fag2)
        {
         case 1:blockshape(370,170,RED,YELLOW,0);break;
         case 2:lineshape(370,170,1,RED,YELLOW,0);break;
         case 3:qishape(370,170,1,RED,YELLOW,0);break;
         case 4:lshape(370,170,1,RED,YELLOW,0);break;
         case 5:tshape(370,170,3,RED,YELLOW,0);break;
         case 6:zshape(370,170,1,RED,YELLOW,0);break;
         case 7:wushape(370,170,2,RED,YELLOW,0);break;
        }
      }
   while(!bioskey(1))
    {
     if(dy<158)
      {
      fag1=fag2;
      fag2=rand()%7+1;
      setfillstyle(SOLID_FILL,GREEN);
      bar(370,170,398,198);
      switch(fag2)
        {
         case 1:blockshape(370,170,RED,YELLOW,0);break;
         case 2:lineshape(370,170,1,RED,YELLOW,0);break;
         case 3:qishape(370,170,1,RED,YELLOW,0);break;
         case 4:lshape(370,170,1,RED,YELLOW,0);break;
         case 5:tshape(370,170,3,RED,YELLOW,0);break;
            case 6:zshape(370,170,1,RED,YELLOW,0);break;
         case 7:wushape(370,170,2,RED,YELLOW,0);break;
        }
      }
     switch(fag1)
      {
      case 1:block_move();break;
      case 2:line_move();break;
      case 3:qi_move();break;
      case 4:l_move();break;
      case 5:t_move();break;
      case 6:z_move();break;
      case 7:wu_move();break;
      }
    }
  press=bioskey(0);
  switch(fag1)
    {
     case 1:block_move2(press);break;
     case 2:line_move2(press);break;
     case 3:qi_move2(press);break;
     case 4:l_move2(press);break;
     case 5:t_move2(press);break;
     case 6:z_move2(press);break;
     case 7:wu_move2(press);break;
    }
  if(press==283)break;
  }
closegraph();
}
int cmpred(int x,int y)
{
int i;
for(i=0;i<28;i++)
  if(getpixel(x+i,y)==RED)return 1;
return 0;
}
int cmpred2(int x,int y)
{
int i;
for(i=0;i<28;i++)
  if(getpixel(x,y+i)==RED)return 1;
return 0;
}
screen()
{
int i;
setbkcolor(BLACK);
setcolor(GREEN);
rectangle(213,150,354,431);
setcolor(BLUE);
rectangle(212,149,355,432);
setfillstyle(SOLID_FILL,BLUE);
floodfill(1,1,1);
setfillstyle(SOLID_FILL,YELLOW);
bar(253,115,305,130);
bar(90,200,150,215);
}

lineshape(int x,int y,int fag,int color1,int color2,int k)
{
if(fag==1)
  {
   if(k==1){
    if(y>424){dy=424;y=dy;}
    if(x>326){dx=326;x=dx;}
    if(x<214){dx=214;x=dx;}
    }
   fang(x,y,color1,color2);
   fang(x+7,y,color1,color2);
   fang(x+14,y,color1,color2);
   fang(x+21,y,color1,color2);
  }
else
  {
   if(k==1){
     if(y>403){dy=403;y=dy;}
     if(x>347){dx=347;x=dx;}
     if(x<214){dx=214;x=dx;}
    }
   fang(x,y,color1,color2);
   fang(x,y+7,color1,color2);
   fang(x,y+14,color1,color2);
   fang(x,y+21,color1,color2);
  }
}

blockshape(int x,int y,int color1,int color2,int k)
{
if(k==1){
   if(y>417){dy=417;y=dy;}
   if(x>340){dx=340;x=dx;}
   if(x<214){dx=214;x=dx;}
  }
fang(x,y,color1,color2);
fang(x,y+7,color1,color2);
fang(x+7,y,color1,color2);
fang(x+7,y+7,color1,color2);
}

qishape(int x,int y,int fag,int color1,int color2,int k)
{
switch(fag)
  {
   case 1:if(k==1)
        {
        if(y>417){dy=417;y=dy;}
        if(x<214){dx=214;x=dx;}
        if(x>333){dx=333;x=dx;}
        }
        fang(x,y,color1,color2);
      fang(x,y+7,color1,color2);
      fang(x+7,y+7,color1,color2);
      fang(x+14,y+7,color1,color2);
      break;
   case 2:if(k==1)
        {
        if(y>417){dy=417;y=dy;}
        if(x<214){dx=214;x=dx;}
        if(x>333){dx=333;x=dx;}
        }
        fang(x,y,color1,color2);
      fang(x+7,y,color1,color2);
      fang(x+14,y,color1,color2);
      fang(x+14,y+7,color1,color2);
      break;
   case 3:if(k==1)
        {
        if(y>410){dy=410;y=dy;}
        if(x<214){dx=214;x=dx;}
        if(x>340){dx=340;x=dx;}
        }
        fang(x,y,color1,color2);
      fang(x+7,y,color1,color2);
      fang(x,y+7,color1,color2);
      fang(x,y+14,color1,color2);
      break;
   case 4:if(k==1)
        {
        if(y>410){dy=410;y=dy;}
        if(x<221){dx=221;x=dx;}
        if(x>347){dx=340;x=dx;}
        }
        fang(x,y,color1,color2);
      fang(x,y+7,color1,color2);
      fang(x,y+14,color1,color2);
      fang(x-7,y+14,color1,color2);
      break;
  }
}
lshape(int x,int y,int fag,int color1,int color2,int k)
{
switch(fag)
  {
   case 1:if(k==1)
        {
        if(y>417){dy=417;y=dy;}
        if(x<214){dx=214;x=dx;}
        if(x>333){dx=333;x=dx;}
        }
        fang(x,y,color1,color2);
      fang(x,y+7,color1,color2);
      fang(x+7,y,color1,color2);
      fang(x+14,y,color1,color2);
      break;
   case 2:if(k==1)
        {
        if(y>410){dy=410;y=dy;}
        if(x<214){dx=214;x=dx;}
        if(x>340){dx=340;x=dx;}
        }
        fang(x,y,color1,color2);
      fang(x+7,y,color1,color2);
      fang(x+7,y+7,color1,color2);
      fang(x+7,y+14,color1,color2);
      break;
   case 3:if(k==1)
        {
        if(y>417){dy=417;y=dy;}
        if(x<228){dx=228;x=dx;}
        if(x>347){dx=347;x=dx;}
        }
        fang(x,y,color1,color2);
      fang(x-7,y+7,color1,color2);
      fang(x-14,y+7,color1,color2);
      fang(x,y+7,color1,color2);
      break;
   case 4:if(k==1)
        {
        if(y>410){dy=410;y=dy;}
        if(x<214){dx=214;x=dx;}
        if(x>340){dx=340;x=dx;}
        }
        fang(x,y,color1,color2);
      fang(x,y+7,color1,color2);
      fang(x,y+14,color1,color2);
      fang(x+7,y+14,color1,color2);
      break;
  }
}
zshape(int x,int y,int fag,int color1,int color2,int k)
{
if(fag==1)
  {
   if(k==1){
    if(y>417){dy=417;y=dy;}
    if(x>333){dx=333;x=dx;}
    if(x<214){dx=214;x=dx;}
    }
   fang(x,y,color1,color2);
   fang(x+7,y,color1,color2);
   fang(x+7,y+7,color1,color2);
   fang(x+14,y+7,color1,color2);
  }
else
  {
   if(k==1){
     if(y>410){dy=410;y=dy;}
     if(x>347){dx=347;x=dx;}
     if(x<221){dx=221;x=dx;}
    }
   fang(x,y,color1,color2);
   fang(x-7,y+7,color1,color2);
   fang(x,y+7,color1,color2);
   fang(x-7,y+14,color1,color2);
  }
}
wushape(int x,int y,int fag,int color1,int color2,int k)
{
if(fag==1)
  {
   if(k==1){
    if(y>417){dy=417;y=dy;}
    if(x>340){dx=340;x=dx;}
    if(x<221){dx=221;x=dx;}
    }
   fang(x,y,color1,color2);
   fang(x+7,y,color1,color2);
   fang(x-7,y+7,color1,color2);
   fang(x,y+7,color1,color2);
  }
else
  {
   if(k==1){
     if(y>410){dy=410;y=dy;}
     if(x>340){dx=340;x=dx;}
     if(x<214){dx=214;x=dx;}
    }
   fang(x,y,color1,color2);
   fang(x,y+7,color1,color2);
   fang(x+7,y+7,color1,color2);
   fang(x+7,y+14,color1,color2);
  }
}
tshape(int x,int y,int fag,int color1,int color2,int k)
{
switch(fag)
  {
   case 1:if(k==1)
        {
        if(y>417){dy=417;y=dy;}
        if(x<221){dx=221;x=dx;}
        if(x>340){dx=340;x=dx;}
        }
        fang(x,y,color1,color2);
      fang(x-7,y+7,color1,color2);
      fang(x,y+7,color1,color2);
      fang(x+7,y+7,color1,color2);
      break;
   case 2:if(k==1)
        {
        if(y>410){dy=410;y=dy;}
        if(x<214){dx=214;x=dx;}
        if(x>340){dx=340;x=dx;}
        }
        fang(x,y,color1,color2);
      fang(x,y+7,color1,color2);
      fang(x,y+14,color1,color2);
      fang(x+7,y+7,color1,color2);
      break;
   case 3:if(k==1)
        {
        if(y>417){dy=417;y=dy;}
        if(x<214){dx=214;x=dx;}
        if(x>333){dx=333;x=dx;}
        }
        fang(x,y,color1,color2);
      fang(x+7,y,color1,color2);
      fang(x+14,y,color1,color2);
      fang(x+7,y+7,color1,color2);
      break;
    case 4:if(k==1)
        {
        if(y>410){dy=410;y=dy;}
        if(x<221){dx=221;x=dx;}
        if(x>347){dx=347;x=dx;}
        }
        fang(x,y,color1,color2);
      fang(x-7,y+7,color1,color2);
      fang(x,y+7,color1,color2);
      fang(x,y+14,color1,color2);
      break;
  }
}

fang(int x,int y,int color1,int color2)
{
setcolor(color1);
rectangle(x,y,x+6,y+6);
setfillstyle(SOLID_FILL,color2);
bar(x+1,y+1,x+5,y+5);
}
cutpage()
{
int x=214,y=430,i,size;
void *buf;
char str[10];
if(cmp_red1(214,151)){gameover();exit(1);}
for(i=0;i<40;i++)
   if(cmpblack(x,y-i*7))
    {
     setfillstyle(SOLID_FILL,BLACK);
     bar(x,y-i*7-6,354,y-i*7);
     size=imagesize(214,151,354,y-i*7-7);
     buf=(void *)malloc(size);
     getimage(214,151,354,y-i*7-7,buf);
     putimage(214,158,buf,COPY_PUT);
     free(buf);
     y+=7;
     score+=10;
     if(score>=5000)
       {
        score=0;
        speed-=5000;
        setfillstyle(SOLID_FILL,YELLOW);
        bar(90,200,150,215);
        switch(speed)
        {
         case 25000:outtextxy(92,205,"LEVER 2");break;
         case 20000:outtextxy(92,205,"LEVER 3");break;
         case 15000:outtextxy(92,205,"LEVER 4");break;
         case 10000:outtextxy(92,205,"LEVER 5");break;
         case 5000: outtextxy(92,205,"LEVER 6");break;
         case 0:   outtextxy(92,205,"LEVER 7");break;
         case -5000:outtextxy(92,205,"LEVER 8");break;
         case -10000:outtextxy(92,205,"LEVER 9");break;
         case -15000:outtextxy(92,205,"LEVER 10");break;
         default:outtextxy(92,205,"WINNER!!!!!");
        }
        leveladd();
        setfillstyle(SOLID_FILL,BLACK);
        bar(214,151,353,430);
       }
     setfillstyle(SOLID_FILL,YELLOW);
     bar(253,115,305,130);
     sprintf(str,"%d",score);
     outtextxy(255,120,str);
    }
}
cmpblack(int x,int y)
{
int i;
for(i=0;i<140;i++)
  if(getpixel(x+i,y)==BLACK)return 0;
return 1;
}
cmp_red1(int x,int y)
{
int i;
for(i=0;i<140;i++)
   if(getpixel(x+i,y)==RED)return 1;
return 0;
}
gameover()
{
int i,sped=10000;
cleardevice();
setfillstyle(SOLID_FILL,BLUE);
bar(1,1,639,80);
setcolor(YELLOW);
settextstyle(4,0,8);
outtextxy(100,200,"GOOD_BYE");
setcolor(LIGHTRED);
setlinestyle(SOLID_LINE,1,1);
for(i=1;i<=320&&!kbhit();i++)
  {
   line(i,80,i,479);
   line(640-i,80,640-i,479);
   delay(sped+i*100);
  }
closegraph();
}
leveladd()
{
setfillstyle(SOLID_FILL,BLACK);
bar(214,151,353,430);
outtextxy(220,300,"YEAH!!!!");
sleep(1);
}

line_move()
{
  tag=tag%2;
  if(tag==0)tag=2;
  lineshape(dx,dy,tag,RED,YELLOW,1);
  delay(speed+35535);
  if(dy>=424&&tag==1){cutpage();dx=270;dy=151;return;}
  if(dy>=403&&tag==2){cutpage();dx=270;dy=151;return;}
  if(tag==1&&cmpred(dx,dy+7)){cutpage();dy=151;dx=270;return;}
  if(tag==2&&getpixel(dx,dy+28)==RED){cutpage();dy=151;dx=270;return;}
  lineshape(dx,dy,tag,BLACK,BLACK,1);
  dy=dy+7;
}
line_move2(int press)
{
  tag=tag%2;
  if(tag==0)tag=2;
  switch(press)
    {
    case 18432:lineshape(dx,dy,tag,BLACK,BLACK,1);
         if(tag==1&&cmpred(dx,dy+7)){tag=1;return;}
         if(tag==2&&cmpred2(dx+7,dy)){tag=2;return;}
         tag=tag%2+1;return;
    case 19200:if(cmpred2(dx-1,dy))return;
         if(dy>424&&tag==1){lineshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>403&&tag==2){lineshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {lineshape(dx,dy,tag,BLACK,BLACK,1);dx=dx-7;if(dx<214)dx=214;break;}
    case 19712:if(cmpred2(dx+7,dy)&&tag==2)return;
         if(getpixel(dx+28,dy)==RED&&tag==1)return;
         if(dy>424&&tag==1){lineshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>403&&tag==2){lineshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {lineshape(dx,dy,tag,BLACK,BLACK,1);dx=dx+7;if(dx>326&&tag==1)dx=326;if(dx>347&&tag==2)dx=347;return;}
    case 20480:lineshape(dx,dy,tag,BLACK,BLACK,1);dy=dy+7;if(dy>424&&tag==1)dy=424;if(dy==403&&tag==2)dy=403;if(tag==1&&cmpred(dx,dy))dy-=7;if(tag==2&&getpixel(dx,dy+21)==RED)dy-=7;return;
    }
}

block_move()
{
  blockshape(dx,dy,RED,YELLOW,1);
  delay(speed+35535);
  if(dy==417){cutpage();dx=270;dy=151;return;}
  if(b_cmpred(dx,dy+14)){cutpage();dy=151;dx=270;return;}
  blockshape(dx,dy,BLACK,BLACK,1);
  dy=dy+7;
}
block_move2(int press)
{
switch(press)
    {
    case 19200:if(b_cmpred2(dx-1,dy))return;
         if(dy>417){blockshape(dx,dy,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {blockshape(dx,dy,BLACK,BLACK,1);dx=dx-7;if(dx<214)dx=214;return;}
    case 19712:if(b_cmpred2(dx+14,dy))return;
         if(dy>417){blockshape(dx,dy,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {blockshape(dx,dy,BLACK,BLACK,1);dx=dx+7;if(dx>340&&tag==0)dx=340;return;}
    case 20480:blockshape(dx,dy,BLACK,BLACK,1);dy=dy+7;
         if(dy>417){dy=417;blockshape(dx,dy,RED,YELLOW,1);dy=151;return;}
         if(b_cmpred(dx,dy+7))dy-=7;return;
    }
}
b_cmpred(int x,int y)
{
int i;
for(i=0;i<14;i++)
  if(getpixel(x+i,y)==RED)return 1;
return 0;
}
b_cmpred2(int x,int y)
{
int i;
for(i=0;i<14;i++)
   if(getpixel(x,y+i)==RED)return 1;
return 0;
}
qi_move()
{
  qishape(dx,dy,tag,RED,YELLOW,1);
  delay(speed+35535);
  if(dy>=417&&tag==1){cutpage();dx=270;dy=151;return;}
  if(dy>=417&&tag==2){cutpage();dx=270;dy=151;return;}
  if(dy>=410&&tag==3){cutpage();dx=270;dy=151;return;}
  if(dy>=410&&tag==4){cutpage();dx=270;dy=151;return;}
  if(tag==1&&qi_cmpred2(dx,dy+14)){cutpage();dy=151;dx=270;return;}
  if(tag==2&&qi_cmpred1(dx,dy)){cutpage();dy=151;dx=270;return;}
  if(tag==3&&(getpixel(dx,dy+21)==RED||getpixel(dx+7,dy+7)==RED)){cutpage();dy=151;dx=270;return;}
  if(tag==4&&b_cmpred(dx-7,dy+21)){cutpage();dy=151;dx=270;return;}
  qishape(dx,dy,tag,BLACK,BLACK,1);
  dy=dy+7;
}
qi_move2(int press)
{
  switch(press)
    {
    case 18432:qishape(dx,dy,tag,BLACK,BLACK,1);
         if(tag==1&&qi_cmpred2(dx,dy+14)){tag=1;return;}
         if(tag==2&&qi_cmpred1(dx,dy)){tag=2;return;}
         if(tag==2&&cmpred(dx-7,dy+14)){tag=2;return;}
         if(tag==3&&(getpixel(dx+14,dy)==RED||getpixel(dx+14,dy+7)==RED)){tag=3;return;}
         if(tag==4&&(getpixel(dx+7,dy)==RED||b_cmpred(dx+7,dy+7)||getpixel(dx-7,dy+14)==RED||getpixel(dx-7,dy+7)==RED)){tag=4;return;}
         if(tag==1){tag=3;return;}
         if(tag==3){tag=2;return;}
         if(tag==2){tag=4;return;}
         if(tag==4){tag=1;return;}
    case 19200:if(b_cmpred2(dx-1,dy)&&tag==1)return;
         if(getpixel(dx-1,dy)==RED||getpixel(dx+7,dy+7)==RED&&tag==2)return;
         if(qi_cmpred3(dx-1,dy)&&tag==3)return;
         if(getpixel(dx-8,dy+14)==RED||b_cmpred2(dx-1,dy)&&tag==4)return;
         if(dy>417&&tag==1){qishape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>417&&tag==2){qishape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==3){qishape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==4){qishape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {qishape(dx,dy,tag,BLACK,BLACK,1);
           dx=dx-7;
           if(dx<214&&tag!=4)dx=214;
           if(dx<221&&tag==4)dx=221;
           break;}
    case 19712:if(getpixel(dx+7,dy)==RED||getpixel(dx+21,dy+7)&&tag==1)return;
         if(b_cmpred2(dx+21,dy)&&tag==2)return;
         if(getpixel(dx+14,dy)==RED||b_cmpred2(dx+7,dy+7)&&tag==3)return;
         if(qi_cmpred3(dx+7,dy)&&tag==4)return;
            if(dy>417&&tag==1){qishape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>417&&tag==2){qishape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==3){qishape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==4){qishape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {qishape(dx,dy,tag,BLACK,BLACK,1);dx=dx+7;
           if(dx>333&&(tag==1||tag==2))dx=333;
           if(dx>340&&tag==3)dx=340;
           if(dx>347&&tag==4)dx=347;
           return;}
    case 20480:qishape(dx,dy,tag,BLACK,BLACK,1);dy=dy+7;
            if(dy>417&&tag==1){qishape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>417&&tag==2){qishape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==3){qishape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==4){qishape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(tag==1&&qi_cmpred2(dx,dy+7))dy-=7;
         if(tag==2&&qi_cmpred1(dx,dy-7))dy-=7;
         if(tag==3&&(getpixel(dx,dy+14)==RED||getpixel(dx+7,dy+7)==RED))dy-=7;
         if(tag==4&&b_cmpred(dx-7,dy+14))dy-=7;
         return;
    }
}
l_move()
{
  lshape(dx,dy,tag,RED,YELLOW,1);
  delay(speed+35535);
  if(dy>=417&&tag==1){cutpage();dx=270;dy=151;return;}
  if(dy>=410&&tag==2){cutpage();dx=270;dy=151;return;}
  if(dy>=417&&tag==3){cutpage();dx=270;dy=151;return;}
  if(dy>=410&&tag==4){cutpage();dx=270;dy=151;return;}
  if(tag==1&&(getpixel(dx,dy+14)==RED||b_cmpred(dx+7,dy+7))){cutpage();dy=151;dx=270;return;}
  if(tag==2&&(getpixel(dx,dy+7)==RED||getpixel(dx+7,dy+21)==RED)){cutpage();dy=151;dx=270;return;}
  if(tag==3&&qi_cmpred2(dx-14,dy+14)){cutpage();dy=151;dx=270;return;}
  if(tag==4&&b_cmpred(dx,dy+21)){cutpage();dy=151;dx=270;return;}
  lshape(dx,dy,tag,BLACK,BLACK,1);
  dy=dy+7;
}
l_move2(int press)
{
  switch(press)
    {
    case 18432:lshape(dx,dy,tag,BLACK,BLACK,1);
         if(tag==1&&(b_cmpred(dx+7,dy+7)||b_cmpred(dx+7,dy+14))){tag=1;return;}
         if(tag==2&&qi_cmpred2(dx-14,dy+7)){tag=2;return;}
         if(tag==2&&b_cmpred(dx-7,dy+14)){tag=2;return;}
         if(tag==3&&(b_cmpred(dx-14,dy)||b_cmpred(dx,dy+14))){tag=3;return;}
         if(tag==4&&(b_cmpred(dx+7,dy)||b_cmpred(dx+7,dy+7)||b_cmpred(dx,dy+21))){tag=4;return;}
         tag=tag%4+1;return;
    case 19200:if(b_cmpred2(dx-1,dy)&&tag==1)return;
         if(getpixel(dx-1,dy)==RED||b_cmpred2(dx+6,dy+7)&&tag==2)return;
         if(getpixel(dx-1,dy)==RED||getpixel(dx-15,dy+7)==RED&&tag==3)return;
         if(qi_cmpred3(dx-1,dy)&&tag==4)return;
         if(dy>417&&tag==1){lshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==2){lshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>417&&tag==3){lshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==4){lshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {lshape(dx,dy,tag,BLACK,BLACK,1);
           dx=dx-7;
           if(dx<214&&tag!=3)dx=214;
           if(dx<228&&tag==3)dx=228;
           break;}
    case 19712:if(getpixel(dx+7,dy+7)==RED||getpixel(dx+21,dy)==RED&&tag==1)return;
         if(qi_cmpred3(dx+14,dy)&&tag==2)return;
         if(b_cmpred2(dx+7,dy)&&tag==3)return;
         if(b_cmpred2(dx+7,dy)||getpixel(dx+14,dy+14)==RED&&tag==4)return;
         if(dy>417&&tag==1){lshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==2){lshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>417&&tag==3){lshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==4){lshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {lshape(dx,dy,tag,BLACK,BLACK,1);dx=dx+7;
           if(dx>333&&tag==1)dx=333;
           if(dx>340&&(tag==2||tag==4))dx=340;
           if(dx>347&&tag==3)dx=347;
           return;}
    case 20480:lshape(dx,dy,tag,BLACK,BLACK,1);
         dy=dy+7;
         if(dy>417&&tag==1){lshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==2){lshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>417&&tag==3){lshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==4){lshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(tag==1&&(getpixel(dx,dy+7)==RED||b_cmpred(dx+7,dy)))dy=dy-7;
         if(tag==2&&(getpixel(dx,dy)==RED||getpixel(dx+7,dy+14)==RED))dy=dy-7;
         if(tag==3&&qi_cmpred2(dx-14,dy+7))dy=dy-7;
         if(tag==4&&b_cmpred(dx,dy+14))dy=dy-7;
         return;
    }
}
t_move()
{
  tshape(dx,dy,tag,RED,YELLOW,1);
  delay(speed+35535);
  if(dy>=417&&tag==1){cutpage();dx=270;dy=151;return;}
  if(dy>=410&&tag==2){cutpage();dx=270;dy=151;return;}
  if(dy>=417&&tag==3){cutpage();dx=270;dy=151;return;}
  if(dy>=410&&tag==4){cutpage();dx=270;dy=151;return;}
  if(tag==1&&qi_cmpred2(dx-7,dy+14)){cutpage();dy=151;dx=270;return;}
  if(tag==2&&(getpixel(dx,dy+21)==RED||getpixel(dx+7,dy+14)==RED)){cutpage();dy=151;dx=270;return;}
  if(tag==3&&(getpixel(dx,dy+7)==RED||getpixel(dx+7,dy+14)==RED||getpixel(dx+14,dy+7)==RED)){cutpage();dy=151;dx=270;return;}
  if(tag==4&&(getpixel(dx,dy+21)==RED||getpixel(dx-7,dy+14)==RED)){cutpage();dy=151;dx=270;return;}
  tshape(dx,dy,tag,BLACK,BLACK,1);
  dy=dy+7;
}
t_move2(int press)
{
switch(press)
    {
    case 18432:tshape(dx,dy,tag,BLACK,BLACK,1);
         if(tag==1&&(getpixel(dx-1,dy)==RED||getpixel(dx+7,dy)==RED||b_cmpred(dx,dy+14))){tag=1;return;}
         if(tag==2&&(getpixel(dx+7,dy)==RED||getpixel(dx+7,dy+14)==RED||b_cmpred(dx-1,dy+7))){tag=2;return;}
         if(tag==3&&(getpixel(dx+14,dy+7)==RED||qi_cmpred2(dx,dy+14)||b_cmpred(dx-7,dy+7))){tag=3;return;}
         if(tag==4&&(getpixel(dx-1,dy)==RED||getpixel(dx-1,dy+14)==RED||b_cmpred(dx+7,dy))){tag=4;return;}
         tag=tag%4+1;return;
    case 19200:if(getpixel(dx-1,dy)==RED||getpixel(dx-8,dy+7)&&tag==1)return;
         if(qi_cmpred3(dx-1,dy)&&tag==2)return;
         if(getpixel(dx-1,dy)==RED||getpixel(dx,dy+7)==RED&&tag==3)return;
         if(getpixel(dx-1,dy)==RED||getpixel(dx-8,dy+7)==RED||getpixel(dx-1,dy+14)==RED&&tag==4)return;
         if(dy>417&&tag==1){tshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==2){tshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>417&&tag==3){tshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==4){tshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {tshape(dx,dy,tag,BLACK,BLACK,1);
           dx=dx-7;
           if(dx<214&&(tag==2||tag==3))dx=214;
           if(dx<221&&(tag==1||tag==4))dx=221;
           break;}
    case 19712:if(getpixel(dx+7,dy)==RED||getpixel(dx+14,dy+7)==RED&&tag==1)return;
         if(getpixel(dx+7,dy)==RED||getpixel(dx+14,dy+7)==RED||getpixel(dx+7,dy+14)==RED&&tag==2)return;
         if(getpixel(dx+21,dy)==RED||getpixel(dx+14,dy+7)==RED&&tag==3)return;
         if(qi_cmpred3(dx+7,dy)&&tag==4)return;
         if(dy>417&&tag==1){tshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==2){tshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>417&&tag==3){tshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==4){tshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {tshape(dx,dy,tag,BLACK,BLACK,1);dx=dx+7;
           if(dx>333&&tag==3)dx=333;
           if(dx>340&&(tag==1||tag==2))dx=340;
           if(dx>347&&tag==4)dx=347;
           return;}
    case 20480:tshape(dx,dy,tag,BLACK,BLACK,1);
         dy=dy+7;
         if(dy>417&&tag==1){tshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==2){tshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>417&&tag==3){tshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==4){tshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(tag==1&&qi_cmpred2(dx-7,dy+7))dy-=7;
         if(tag==2&&(getpixel(dx,dy+14)==RED||getpixel(dx+7,dy+7)==RED))dy-=7;
         if(tag==3&&(getpixel(dx,dy)==RED||getpixel(dx+7,dy+7)==RED||getpixel(dx+14,dy)==RED))dy-=7;
         if(tag==4&&(getpixel(dx,dy+14)==RED||getpixel(dx-7,dy+7)==RED))dy-=7;
         return;
    }
}
z_move()
{
  tag=tag%2;
  if(tag==0)tag=2;
  zshape(dx,dy,tag,RED,YELLOW,1);
  delay(speed+35535);
  if(dy>=417&&tag==1){cutpage();dx=270;dy=151;return;}
  if(dy>=410&&tag==2){cutpage();dx=270;dy=151;return;}
  if(tag==1&&(getpixel(dx,dy+7)==RED||b_cmpred(dx+7,dy+14))){cutpage();dy=151;dx=270;return;}
  if(tag==2&&(getpixel(dx-7,dy+21)==RED||getpixel(dx,dy+14)==RED)){cutpage();dy=151;dx=270;return;}
  zshape(dx,dy,tag,BLACK,BLACK,1);
  dy=dy+7;
}
z_move2(int press)
{
  tag=tag%2;
  if(tag==0)tag=2;
  switch(press)
    {
    case 18432:zshape(dx,dy,tag,BLACK,BLACK,1);
         if(tag==1&&(cmpred(dx-7,dy+14)||b_cmpred(dx-7,dy+7))){tag=1;return;}
         if(tag==2&&(qi_cmpred3(dx-14,dy)||getpixel(dx-1,dy)==RED)){tag=2;return;}
         tag=tag%2+1;return;
    case 19200:if(getpixel(dx-1,dy)==RED||getpixel(dx,dy+7)==RED&&tag==1)return;
         if(getpixel(dx-1,dy)==RED||b_cmpred2(dx-7,dy+7)&&tag==2)return;
         if(dy>417&&tag==1){zshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==2){zshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {zshape(dx,dy,tag,BLACK,BLACK,1);dx=dx-7;
           if(dx<214&&tag==1)dx=214;
           if(dx<221&&tag==2)dx=221;
           return;
          }
    case 19712:if(getpixel(dx+14,dy)==RED||getpixel(dx+21,dy+7)==RED&&tag==1)return;
         if(b_cmpred2(dx+7,dy)||getpixel(dx,dy+14)==RED&&tag==2)return;
         if(dy>417&&tag==1){zshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==2){zshape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {zshape(dx,dy,tag,BLACK,BLACK,1);dx=dx+7;if(dx>333&&tag==1)dx=333;if(dx>347&&tag==2)dx=347;return;}
    case 20480:zshape(dx,dy,tag,BLACK,BLACK,1);dy=dy+7;
         if(tag==1&&(getpixel(dx,dy)==RED||b_cmpred(dx+7,dy+7)))dy-=7;
         if(tag==2&&(getpixel(dx-7,dy+14)==RED||getpixel(dx,dy+7)==RED))dy-=7;
         return;
    }
}
wu_move()
{
  tag=tag%2;
  if(tag==0)tag=2;
  wushape(dx,dy,tag,RED,YELLOW,1);
  delay(speed+35535);
  if(dy>=417&&tag==1){cutpage();dx=270;dy=151;return;}
  if(dy>=410&&tag==2){cutpage();dx=270;dy=151;return;}
  if(tag==1&&(getpixel(dx+7,dy+7)==RED||b_cmpred(dx-7,dy+14))){cutpage();dy=151;dx=270;return;}
  if(tag==2&&(getpixel(dx,dy+14)==RED||getpixel(dx+7,dy+21)==RED)){cutpage();dy=151;dx=270;return;}
  wushape(dx,dy,tag,BLACK,BLACK,1);
  dy=dy+7;
}
wu_move2(int press)
{
  tag=tag%2;
  if(tag==0)tag=2;
  switch(press)
    {
    case 18432:wushape(dx,dy,tag,BLACK,BLACK,1);
         if(tag==1&&(getpixel(dx-1,dy)==RED||qi_cmpred2(dx-7,dy+14)||getpixel(dx+7,dy+7)==RED)){tag=1;return;}
         if(tag==2&&(getpixel(dx+7,dy)==RED||b_cmpred(dx-7,dy+14)||getpixel(dx-7,dy+7)==RED)){tag=2;return;}
         tag=tag%2+1;return;
    case 19200:if(getpixel(dx-1,dy)==RED||getpixel(dx-7,dy+7)==RED&&tag==1)return;
         if(getpixel(dx,dy+14)==RED||b_cmpred2(dx-1,dy)&&tag==2)return;
         if(dy>417&&tag==1){wushape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==2){wushape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {wushape(dx,dy,tag,BLACK,BLACK,1);dx=dx-7;
           if(dx<221&&tag==1)dx=221;
           if(dx<214&&tag==2)dx=214;
           return;
          }
    case 19712:if(getpixel(dx+14,dy)==RED||getpixel(dx+7,dy+7)==RED&&tag==1)return;
         if(b_cmpred2(dx+14,dy+7)||getpixel(dx+7,dy)==RED&&tag==2)return;
         if(dy>417&&tag==1){wushape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         if(dy>410&&tag==2){wushape(dx,dy,tag,RED,YELLOW,1);cutpage();dx=270;dy=151;return;}
         else
          {wushape(dx,dy,tag,BLACK,BLACK,1);dx=dx+7;if(dx>340)dx=340;return;}
    case 20480:wushape(dx,dy,tag,BLACK,BLACK,1);dy=dy+7;
         if(tag==1&&(getpixel(dx+7,dy)==RED||b_cmpred(dx-7,dy+7)))dy-=7;
         if(tag==2&&(getpixel(dx,dy+7)==RED||getpixel(dx+7,dy+14)==RED))dy-=7;
         return;
    }
}

qi_cmpred1(int x,int y)
{
int i;
for(i=0;i<14;i++)
  if(getpixel(x+i,y+7)==RED)return 1;
for(i=0;i<7;i++)
  if(getpixel(x+14+i,y+14)==RED)return 1;
return 0;
}
qi_cmpred2(int x,int y)
{
int i;
for(i=0;i<21;i++)
  if(getpixel(x+i,y)==RED)return 1;
return 0;
}
qi_cmpred3(int x,int y)
{
int i;
for(i=0;i<21;i++)
   if(getpixel(x,y+i)==RED)return 1;
return 0;
}
inicrack()
{
blockshape(214,200,RED,YELLOW,0);
lineshape(214,220,1,RED,YELLOW,0);
lineshape(250,200,0,RED,YELLOW,0);
qishape(214,240,1,RED,YELLOW,0);
qishape(240,240,2,RED,YELLOW,0);
qishape(270,240,3,RED,YELLOW,0);
qishape(290,240,4,RED,YELLOW,0);
lshape(214,270,1,RED,YELLOW,0);
lshape(240,270,2,RED,YELLOW,0);
lshape(272,277,3,RED,YELLOW,0);
lshape(290,270,4,RED,YELLOW,0);
zshape(214,300,1,RED,YELLOW,0);
zshape(245,300,2,RED,YELLOW,0);
wushape(214,325,1,RED,YELLOW,0);
wushape(240,325,2,RED,YELLOW,0);
tshape(214,350,1,RED,YELLOW,0);
tshape(240,357,2,RED,YELLOW,0);
tshape(260,350,3,RED,YELLOW,0);
tshape(290,350,4,RED,YELLOW,0);
}


作者: xiaohui_82    时间: 2005-3-2 14:52

文件大小计算
复制内容到剪贴板
代码:
#include<stdio.h>
#include<dir.h>
#include<dos.h>
#include<sys\stat.h>
#include<time.h>
#include<conio.h>
#include<bios.h>
#include<string.h>      /* 头文件 */

#define UP 18432
#define DOWN 20480
#define ENTER 7181
#define ESC 283
#define C 11875        /* UP 向上箭头 DOWN 向下箭头 ENTER 回车键 ESC Esc键  C c键 */

int fileSIZE[16];      /* 某目录文件的总大小,用数组表示 */
int fileNUM[8];       /* 某目录文件的总个数包括原目录本身 */
int subPATH[8];       /* 子目录 */
int avSIZE[16];       /* 某目录中文件的平均长度 */
int avNUM[8];        /* 某目录中文件的平均个数 */
int row,col;         /* 屏幕中显示的位置 */
char pathNAME[256];    /* 路径名称 */
char lastPATH[256];    /* 该目录上级名称 */
char Disk[26];        /* 由于使用的是windows系统,所以获取了磁盘的盘符 */
int diskNUM;         /* 磁盘的个数 */

typedef struct filelist{
char filename[20];
struct filelist *next;
}FList;             /* 文件名列表 */

FList *filelist;      

void addSize(long fsize){     /* 文件长度加法运算,获取文件的长度,将它存入数组中 */
long quotient=fsize/10;
int residue=fsize%10,i=0,c=0;
while(quotient!=0){
    fileSIZE[i]+=residue+c;
    c=fileSIZE[i]/10;
    fileSIZE[i]%=10;
    residue=quotient%10;
    quotient/=10;
    i++;
   }
fileSIZE[i]+=residue+c;
while(fileSIZE[i]/10!=0){
   c=fileSIZE[i]/10;
   fileSIZE[i]%=10;
   i++;
   fileSIZE[i]+=c;
  }
}               

void addNUM(int fnum){    /* 文件数目加法运算,获取文件个数,将它存入数组中 */  
int quotient=fnum/10;
int residue=fnum%10,i=0,c=0;
while(quotient!=0){
    fileNUM[i]+=residue+c;
    c=fileNUM[i]/10;
    fileNUM[i]%=10;
    residue=quotient%10;
    quotient/=10;
    i++;
   }
fileNUM[i]+=residue+c;
while(fileNUM[i]/10!=0){
   c=fileNUM[i]/10;
   fileNUM[i]%=10;
   i++;
   fileNUM[i]+=c;
  }
}

void addSub(int fsub){  /* 子目录个数加法运算,获取子目录个数,将它存入数组中 */
int quotient=fsub/10;
int residue=fsub%10,i=0,c=0;
while(quotient!=0){
    subPATH[i]+=residue+c;
    c=subPATH[i]/10;
    subPATH[i]%=10;
    residue=quotient%10;
    quotient/=10;
    i++;
   }
subPATH[i]+=residue+c;
while(subPATH[i]/10!=0){
   c=subPATH[i]/10;
   subPATH[i++]%=10;
   subPATH[i]+=c;
  }
}

void divSN(){  /* 平均长度求法,获取本目录文件平均长度,采用数组相除 */
int fnum[8];
int fsize[16];

int bS=15,bN=7,bA;
int i,j,k,q,t,m,p,x;

for(i=0;i<8;i++)fnum[i]=fileNUM[i];
for(i=0;i<16;i++)fsize[i]=fileSIZE[i];
for(i=0;i<16;i++)avSIZE[i]=0;

while(fsize[bS]==0&&bS!=-1)bS--;
if(bS==-1)return;
while(fnum[bN]==0&&bN!=-1)bN--;
if(bN==-1)return;
bA=bS-bN;
i=bS;
j=bN;
k=bA;

while(k!=-1){
    if(i-k<=j&&fsize[i]<fnum[j])avSIZE[k]=0;
    else{
      m=0;
      if(i-k>j){
       while(i-k>j){
         for(t=k,p=0;t<=i;t++,p++){
          if(fsize[t]-fnum[p]<0){fsize[t+1]-=1;fsize[t]+=10-fnum[p];}
          else fsize[t]-=fnum[p];
         }
         m++;
         if(fsize[i]==0)i--;
        }
        }
       while(fsize[i]>=fnum[j]){
        if(fsize[i]==fnum[j]){
        x=i;
        p=j;
        while(fsize[x]==fnum[p]&&x>=k){x--;p--;};
        if(fsize[x]<fnum[p]&&x+1!=k)break;
         }
       for(t=i-j,p=0;t<=i;t++,p++){
        if(fsize[t]-fnum[p]<0){fsize[t+1]-=1;fsize[t]+=10-fnum[p];}
        else fsize[t]-=fnum[p];
         }
       m++;
      }
    avSIZE[k]=m;
     }
    k--;
    if(fsize[i]==0)i--;
   }
}

void divNP(){  /* 每目录的平均文件个数求法,获取平均个数,采用数组相除 */
int spath[8];
int fnum[8];
int bS=7,bN=7,bA;
int i,j,k,q,t,m,p,x;

for(i=0;i<8;i++)spath[i]=subPATH[i];
for(i=0;i<8;i++)fnum[i]=fileNUM[i];

while(fnum[bS]==0&&bS!=-1)bS--;
if(bS==-1)return;
while(spath[bN]==0&&bN!=-1)bN--;
if(bN==-1)return;
bA=bS-bN;
i=bS;
j=bN;
k=bA;

while(k!=-1){
    if(i-k<=j&&fnum[i]<spath[j])avNUM[k]=0;
    else{
      m=0;
      if(i-k>j){
       while(i-k>j){
         for(t=k,p=0;t<=i;t++,p++){
          if(fnum[t]-spath[p]<0){fnum[t+1]-=1;fnum[t]+=10-spath[p];}
          else fnum[t]-=spath[p];
         }
         m++;
         if(fnum[i]==0)i--;
        }
        }
       while(fnum[i]>=spath[j]){
        if(fnum[i]==spath[j]){
        x=i;
        p=j;
        while(fnum[x]==spath[p]&&x>=k){x--;p--;};
        if(fnum[x]<spath[p]&&x+1!=k)break;
         }
       for(t=i-j,p=0;t<=i;t++,p++){
        if(fnum[t]-spath[p]<0){fnum[t+1]-=1;fnum[t]+=10-spath[p];}
        else fnum[t]-=spath[p];
         }
       m++;
      }
    avNUM[k]=m;
     }
    k--;
    if(fnum[i]==0)i--;
   }
}

void curFILE(char pathname[]){  /* 递归读取目录信息,获取文件平均长度,平均个数信息 */
struct ffblk ffblk;
struct stat filestat;
char fname[256],fpname[256],subpath[256],subpath1[256];
int done;

strcpy(fname,pathname);
strcat(fname,"\\*.*");
addSub(1);
done=findfirst(fname,&ffblk,0x26);
while(!done){
  addNUM(1);
  strcpy(fpname,pathname);
  strcat(fpname,"\\");
  strcat(fpname,ffblk.ff_name);
  stat(fpname,&filestat);
  addSize(filestat.st_size);
  done=findnext(&ffblk);
}
strcpy(subpath,pathname);
strcat(subpath,"\\*.*");
done=findfirst(subpath,&ffblk,FA_DIREC);
while(!done){
  if(ffblk.ff_attrib&FA_DIREC&&stricmp(ffblk.ff_name,".")&&stricmp(ffblk.ff_name,"..")){
  strcpy(subpath1,pathname);
  strcat(subpath1,"\\");
  strcat(subpath1,ffblk.ff_name);
  curFILE(subpath1);    /* 递归搜索目录 */
  }
  done=findnext(&ffblk);
}
}

display(){  /* 将信息显示在屏幕上 */
int i;

i=15;
textbackground(BLACK);
textcolor(RED);
window(23,6,77,20);
clrscr();
window(2,2,79,24);
while(fileSIZE[i]==0&&i!=-1)i--;
if(i==-1){gotoxy(22,5);cprintf("Size of file in bytes:0 bytes");}
else{
  gotoxy(22,5);
  cprintf("Size of file in bytes:");
  while(i!=-1)cprintf("%d",fileSIZE[i--]);
  cprintf(" bytes");
  }

for(i=0;i<15;i++)avSIZE[i]=0;
for(i=0;i<8;i++)avNUM[i]=0;
i=7;
while(fileNUM[i]==0&&i!=-1)i--;
if(i==-1){gotoxy(22,6);cprintf("Amount of file:0");}
else{
  gotoxy(22,6);
  cprintf("Amount of file:");
  while(i!=-1)cprintf("%d",fileNUM[i--]);
  }

i=7;
while(subPATH[i]==0&&i!=-1)i--;
if(i==-1){gotoxy(22,7);cprintf("Amount of subpath:0");}
else{
  gotoxy(22,7);
  cprintf("Amount of subpath:");
  while(i!=-1)cprintf("%d",subPATH[i--]);
  }

divSN();
i=15;
while(avSIZE[i]==0&&i!=-1)i--;
if(i==-1){gotoxy(22,8);cprintf("Average Size of file in bytes:0 bytes");}
else{
  gotoxy(22,8);
  cprintf("Average Size of file in bytes:");
  while(i!=-1)cprintf("%d",avSIZE[i--]);
  cprintf(" bytes");
  }

divNP();
i=7;
while(avNUM[i]==0&&i!=-1)i--;
if(i==-1){gotoxy(22,9);printf("Average Amount file :0 \n");}
else{
  gotoxy(22,9);
  cprintf("Average Amount file:");
  while(i!=-1)cprintf("%d",avNUM[i--]);
  }
}

initarray(){  /* 初始化各信息数组 */
int i;

for(i=0;i<8;i++)fileNUM[i]=0;
for(i=0;i<15;i++)fileSIZE[i]=0;
for(i=0;i<8;i++)subPATH[i]=0;
for(i=0;i<15;i++)avSIZE[i]=0;
for(i=0;i<8;i++)avNUM[i]=0;
}

interface(){  /* 初始化界面 */
int i;

textmode(BW80);  /* 总界面 */
textbackground(GREEN);
window(1,1,80,25);
clrscr();
textbackground(BLACK);
window(2,2,79,24);
clrscr();

textcolor(RED); /* 目录所有文件,子目录显示区域 */
putch(218);
for(i=1;i<19;i++)putch(196);putch(191);
for(i=1;i<22;i++){gotoxy(1,i+1);putch(179);}
gotoxy(1,i+1);putch(192);
for(i=1;i<19;i++)putch(196);putch(217);
for(i=1;i<22;i++){gotoxy(20,i+1);putch(179);}

gotoxy(21,1);  /* 当前目录路径显示区域 */
putch(218);
for(i=1;i<56;i++)putch(196);putch(191);
gotoxy(21,2);putch(179);
gotoxy(21,3);putch(192);
for(i=1;i<56;i++)putch(196);putch(217);
gotoxy(77,2);putch(179);

gotoxy(21,4);  /* 文件信息显示区域 */
putch(218);
for(i=1;i<56;i++)putch(196);putch(191);
for(i=1;i<16;i++){gotoxy(21,i+4);putch(179);}
gotoxy(21,i+4);putch(192);
for(i=1;i<56;i++)putch(196);putch(217);
for(i=1;i<16;i++){gotoxy(77,i+4);putch(179);}

gotoxy(21,21); /* 提示信息显示区域 */
putch(218);
for(i=1;i<56;i++)putch(196);putch(191);
gotoxy(21,22);putch(179);
gotoxy(21,23);putch(192);
for(i=1;i<56;i++)putch(196);putch(217);
gotoxy(77,22);putch(179);
gotoxy(22,22);
cprintf("\30 \31 choose file..  ENTER selected..  C counting files..");

gotoxy(2,2);
}

void Fileprint(char pathname[]){  /* 当前目录所有文件及所有子目录添加至列表中 */
struct ffblk ffblk;
char fname[256],subpath[256],subpath1[256],fn[20];
int done;
FList *p,*p1;
p=filelist;
while(p!=NULL){p1=p->next;free(p);p=p1;}
filelist=NULL;

strcpy(fname,pathname);
strcat(fname,"\\*.*");
done=findfirst(fname,&ffblk,0x26);

while(!done){
  strcpy(fn,ffblk.ff_name);
  addfname(fn);
  done=findnext(&ffblk);
}
strcpy(subpath,pathname);
strcat(subpath,"\\*.*");
done=findfirst(subpath,&ffblk,0x16);
while(!done){
  if(ffblk.ff_attrib&FA_DIREC&&stricmp(ffblk.ff_name,".")&&stricmp(ffblk.ff_name,"..")){
  strcpy(fn,ffblk.ff_name);
  strcat(fn,"\\");
  addfname(fn);
  }
  done=findnext(&ffblk);
}
addfname("\\..");
}

addfname(char *fname){  /* 列表添加文件信息 */
FList *p,*p1;
p=(FList *)malloc(sizeof(FList));
strcpy(p->filename,fname);
p->next=NULL;
if(filelist==NULL)filelist=p;
else{
  p1=filelist;
  while(p1->next!=NULL)p1=p1->next;
  p1->next=p;
}
}

int cmpslash(char path[]){  /* 如果当前为子目录返回1,否则返回0 */
if(path[strlen(path)-1]==&#39;\\&#39;)return 1;
else return(0);
}

int cmpsdot(char path[]){
int l;
l=strlen(path);
if(path[l-3]==&#39;\\&#39;&&path[l-2]==&#39;.&#39;&&path[l-1]==&#39;.&#39;)return 1;
else return(0);
}

int existslash(char path[])  /* 如果上一级非盘符,则返回最后&#39;\&#39;的位置,否则返回0 */
{
char *p;
p=strrchr(path,&#39;\\&#39;);
if(p)return p-path;
else return 0;
}

initdisk(){      /* 获取盘符过程 */
int save,disk;
FList *p,*p1;
int i=0;
char fname[20];
p=filelist;
while(p!=NULL){p1=p->next;free(p);p=p1;}
filelist=NULL;
save=getdisk();
for(disk=0;disk<26;++disk){
   setdisk(disk);
   if(disk==getdisk()){
     fname[0]=disk+&#39;a&#39;;
     Disk[i]=disk+&#39;a&#39;;
     i++;
     fname[1]=&#39;:&#39;;
     fname[2]=&#39;\0&#39;;
     addfname(fname);
    }
  }
diskNUM=i;
setdisk(save);
strcpy(lastPATH,filelist->filename);
strcpy(pathNAME,filelist->filename);
}

initlist(){   /* 初始化列表为盘符列表 */
char fname[20];
FList *p,*p1;
int i;
p=filelist;
while(p!=NULL){p1=p->next;free(p);p=p1;}
filelist=NULL;
for(i=0;i<diskNUM;i++){
     fname[0]=Disk[i];
     fname[1]=&#39;:&#39;;
     fname[2]=&#39;\0&#39;;
     addfname(fname);
    }
}

isdisk(char path[]){     /* 当前路径为盘符则返回1,否则返回0 */
char fname[20];
int i=0;
for(i=0;i<diskNUM;i++){
     fname[0]=Disk[i];
     fname[1]=&#39;:&#39;;
     fname[2]=&#39;\0&#39;;
     if(!stricmp(fname,path))return 1;
    }
return(0);
}

printfname(){     /* 打印列表,并完成各种操作 */
FList *p,*pw;
int r;
int i,omit=0;
int key;
p=filelist;
window(3,3,20,23);clrscr();window(2,2,79,24);row=2;col=2;textcolor(RED);
while(p!=NULL){
  gotoxy(col,row);
  cprintf("%s",p->filename);
  p=p->next;
  row++;
  if(row>22)break;
}
r=2;
textbackground(WHITE);
textcolor(BLACK);
window(3,r+1,20,r+1);
pw=filelist;
for(i=2;i<r;i++){
  pw=pw->next;
  if(pw==NULL)break;
  }
cprintf("%s",pw->filename);
textbackground(BLACK);
textcolor(RED);
window(23,3,77,3);
clrscr();
if(!isdisk(lastPATH)||(isdisk(lastPATH)&&!isdisk(pw->filename))){
  strcpy(pathNAME,lastPATH);
  strcat(pathNAME,"\\");
  strcat(pathNAME,pw->filename);
  }
else {strcpy(lastPATH,pw->filename);strcpy(pathNAME,pw->filename);}
textbackground(BLACK);
textcolor(RED);
window(2,2,79,24);
gotoxy(22,2);
cprintf("%s",pathNAME);
gotoxy(2,r);
while(1){
   key=bioskey(0);
   if(key==ESC)exit(1);          /*  按下ESC键退出程序 */
   if(key==DOWN){              /*  按下向下键进行选择,得到滚屏效果 */
    if(r==22){
       if(pw->next!=NULL){
        omit++;
        window(3,3,20,23);
        clrscr();
        textbackground(BLACK);
        textcolor(RED);
        window(2,2,79,24);
        pw=filelist;
        for(i=0;i<omit;i++)pw=pw->next;
        for(i=2;i<r;i++){
        gotoxy(2,i);
        cprintf("%s",pw->filename);
        pw=pw->next;
         }
        textbackground(WHITE);
        textcolor(BLACK);
        window(3,r+1,20,r+1);
        cprintf("%s",pw->filename);
          textbackground(BLACK);
        textcolor(RED);
        window(23,3,77,3);
        clrscr();
          if(!isdisk(lastPATH)||(isdisk(lastPATH)&&!isdisk(pw->filename))){
           strcpy(pathNAME,lastPATH);
           strcat(pathNAME,"\\");
           strcat(pathNAME,pw->filename);
          }
        else {strcpy(lastPATH,pw->filename);strcpy(pathNAME,pw->filename);}
        textbackground(BLACK);
        textcolor(RED);
        window(2,2,79,24);
          gotoxy(22,2);
        cprintf("%s",pathNAME);
        gotoxy(2,r);
        }
      }
    else{
      textbackground(BLACK);
      textcolor(RED);
      window(3,r+1,20,r+1);
      pw=filelist;
       for(i=0;i<omit;i++)pw=pw->next;
      for(i=2;i<r;i++){
        pw=pw->next;
        if(pw==NULL)break;
       }
      if(pw!=NULL&&pw->next!=NULL)cprintf("%s",pw->filename);
      if(pw!=NULL&&pw->next!=NULL)r++;
      textbackground(WHITE);
      textcolor(BLACK);
      window(3,r+1,20,r+1);
      pw=filelist;
       for(i=0;i<omit;i++)pw=pw->next;
      for(i=2;i<r;i++){
        pw=pw->next;
        if(pw==NULL)break;
       }
      if(pw!=NULL)cprintf("%s",pw->filename);
       textbackground(BLACK);
      textcolor(RED);
      window(23,3,77,3);
      clrscr();
       if(!isdisk(lastPATH)||(isdisk(lastPATH)&&!isdisk(pw->filename))){
           strcpy(pathNAME,lastPATH);
           strcat(pathNAME,"\\");
           strcat(pathNAME,pw->filename);
          }
      else {strcpy(lastPATH,pw->filename);strcpy(pathNAME,pw->filename);}
      textbackground(BLACK);
      textcolor(RED);
      window(2,2,79,24);
       gotoxy(22,2);
      cprintf("%s",pathNAME);
      if(pw!=NULL)gotoxy(2,r);
      else gotoxy(2,i);
     }
    }
  if(key==UP){            /*  按下向上键进行选择,得到滚屏效果 */
    if(r==2){
        window(3,3,20,23);
       clrscr();
       if(pw!=filelist)omit--;
        textbackground(BLACK);
       textcolor(RED);
       window(3,r+1,20,r+1);
       pw=filelist;
       for(i=0;i<omit;i++)pw=pw->next;
       if(pw!=filelist)cprintf("%s",pw->filename);
        textbackground(WHITE);
       textcolor(BLACK);
       window(3,r+1,20,r+1);
       pw=filelist;
       for(i=0;i<omit;i++)pw=pw->next;
       cprintf("%s",pw->filename);
       p=pw->next;
       row=r+1;
       while(p!=NULL){
        textbackground(BLACK);
        textcolor(RED);
        window(3,row+1,20,row+1);
        cprintf("%s",p->filename);
        p=p->next;
        row++;
        if(row>22)break;
        }
        textbackground(BLACK);
       textcolor(RED);
       window(23,3,77,3);
       clrscr();
        if(!isdisk(lastPATH)||(isdisk(lastPATH)&&!isdisk(pw->filename))){
           strcpy(pathNAME,lastPATH);
           strcat(pathNAME,"\\");
           strcat(pathNAME,pw->filename);
          }
       else {strcpy(lastPATH,pw->filename);strcpy(pathNAME,pw->filename);}
       window(2,2,79,24);
        gotoxy(22,2);
       cprintf("%s",pathNAME);
       gotoxy(2,r);
      }
    else{
      textbackground(BLACK);
      textcolor(RED);
      window(3,r+1,20,r+1);
      pw=filelist;
      for(i=0;i<omit;i++)pw=pw->next;
      for(i=2;i<r;i++){
        pw=pw->next;
        if(pw==NULL)break;
       }
      if(pw!=NULL)cprintf("%s",pw->filename);
      r--;
      textbackground(WHITE);
      textcolor(BLACK);
      window(3,r+1,20,r+1);
      pw=filelist;
       for(i=0;i<omit;i++)pw=pw->next;
      for(i=2;i<r;i++){
        pw=pw->next;
        if(pw==NULL)break;
       }
      if(pw!=filelist)cprintf("%s",pw->filename);
       textbackground(BLACK);
      textcolor(RED);
      window(23,3,77,3);
      clrscr();
       if(!isdisk(lastPATH)||(isdisk(lastPATH)&&!isdisk(pw->filename))){
           strcpy(pathNAME,lastPATH);
           strcat(pathNAME,"\\");
           strcat(pathNAME,pw->filename);
          }
      else {strcpy(lastPATH,pw->filename);strcpy(pathNAME,pw->filename);}
      textbackground(BLACK);
      textcolor(RED);
      window(2,2,79,24);
      gotoxy(22,2);
      cprintf("%s",pathNAME);
      if(pw!=filelist)gotoxy(2,r);
      else gotoxy(2,i);
     }
    }
  if(key==ENTER){          /*  按下回车键进入子目录 */
    if(isdisk(pathNAME)){
    strcpy(lastPATH,pathNAME);
    Fileprint(pathNAME);
    printfname();
     }
    else if(cmpslash(pathNAME)){
    pathNAME[strlen(pathNAME)-1]=&#39;\0&#39;;
      strcpy(lastPATH,pathNAME);
    Fileprint(pathNAME);
    printfname();
     }
    else if(cmpsdot(pathNAME)){
    if(existslash(lastPATH)){
       lastPATH[existslash(lastPATH)]=&#39;\0&#39;;
       strcpy(pathNAME,lastPATH);
       Fileprint(pathNAME);
       printfname();
      }
    else if(isdisk(lastPATH)){initlist();printfname();}
     }
   }
  if(key==C){        /*  按下&#39;c&#39;键,进行计算,获取文件信息 */
    textbackground(BLACK);
    textcolor(RED);
    window(23,6,77,20);
    clrscr();
    window(2,2,79,24);
    gotoxy(22,5);
    cprintf("Waiting...");
    initarray();
    curFILE(pathNAME);
    display();
   }
}
}

main(){      /* 主函数 */
char s[256];
filelist=NULL;
initarray();
interface();
gotoxy(22,2);
initdisk();
initlist();
printfname();
}

作者: 冰血封情    时间: 2005-3-10 16:24

数组练习
复制内容到剪贴板
代码:
//preprocess directive
#include <stdio.h>

const int MAX = 13;  //VC6下通过这样的定义 但是不推荐

float expenses[MAX], max;
int count;

int main(void)
{
    //input data from keyboard into array

    for ( count = 1; count < 13; count++ )
    {
        printf("Enter expenses for month %d: ", count);
        scanf("%f", &expenses[count]);
        max += expenses[count];
    }

    //print array contents

    for ( count = 1; count < 13;  count++ )
    {
        printf("Month %d = $%.2f\n", count,  expenses[count]);
    }
    printf("Max is $%.2f\n", max);
    printf("The average is $%.2f\n", max/12);
    return 0;
}

作者: 冰血封情    时间: 2005-3-10 16:25

复制内容到剪贴板
代码:
//by bideyore and eviloctal

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

void do_heading( char *filename, FILE * dic );  //函数原型

int line = 0, page = 0;  //声明初始化行和页

int main( int argv, char *argc[] )
{
char buffer[256];  //声明缓冲区
FILE *fp;  //源代码文件名
FILE *dic;  //目标文件名

if( argv < 2 )  //如果参数数量不对就打印使用说明
{
fprintf(stderr, "\nProper Usage is: ");
fprintf(stderr, "\n\nprint filename.txt\n");
return 1;
}
if (( fp = fopen ( argc[1], "r" )) == NULL )  //以只读方式打开 失败就报错
{

fprintf( stderr, "Error opening file, %s!", argc[1]);
return 1;
}

if (( dic = fopen ( argc[2], "w+" )) == NULL )  //打开一个新文件 没有就创建
{

fprintf( stderr, "Error opening file, %s!", argc[2]);  //失败报错
return 1;
}

page = 0;  //定义页为零
line = 1;  //从第一行开始
do_heading( argc[1] , dic );  //看下面

while ( fgets (buffer, 256, fp ) != NULL )  //一次读一行的前256个
{
if ( line % 55 == 0 )  //检查是不是一页
do_heading( argc[1] , dic);  //够一页就打印子函数 这次完全执行

fprintf(dic, "%4d:\t%s", line++, buffer );  //不够朝文件写入行号和读来的内容
}
fprintf(dic, "\f");
fclose(dic);  //释放资源
fclose(fp);
return 0;
}


void do_heading( char *filename, FILE * dic)
{
page++;  //第一次执行页变成一

if ( page > 1 )  //第一次执行页是一不进入循环
fprintf(dic, "\f" );

fprintf( dic, "page: %d, %s\n\n", page, filename );
}

作者: 冰血封情    时间: 2005-3-10 16:25

复制内容到剪贴板
代码:
//by EvilOctal
#include <stdio.h>
#include <stdlib.h>

int a[5][4], b[5][4];

int main(void)
{
    int x, y, c, d;
    for (x = 0; x < 5; x++)  //把数组a赋随机值
    {
        for (y = 0; y < 4; y++)
        {
            a[x][y] = rand();
        }
    }
    for (x = 0; x < 5; x++)  //打印刚才的赋值情况
    {
        for (y = 0; y < 4; y++)
        {
            printf("The a[%d][%d] is %d!\n", x, y, a[x][y]);
        }
    }
    for (x = 0, c = 4; x < 5, c >= 0; x++, c--)  //把数组a的所有元素反向赋值到b中
    {
        for (y = 0, d = 3; y < 4, d >= 0; y++, d--)
        {
            b[c][d] = a[x][y];
        }
    }
    for (c = 0; c < 5; c++)  //检查反向赋值的结果
    {
        for (d = 0; d < 4; d++)
        {
            printf("The b[%d][%d] is %d!\n", c, d, b[c][d]);
        }
    }
    return 0;
}
//糊涂了for的判断条件 脑袋已经秀逗了
//忽略了数组最大的下标是n-1 他妈的我傻逼 书上强调3次 自己还埋怨罗嗦 到头来还是错在这里
//其实使用双重计算是多此一举

作者: 冰血封情    时间: 2005-3-10 16:25

复制内容到剪贴板
代码:
// Passing an array to a function.

#include <stdio.h>

#define MAX 10

int array[MAX], count, *ptr;

int largest(int *num_array, int length);
int least(int num_array[], int length);

int main( void )
{
    ptr = array;

   for (count = 0; count < MAX; count++)
   {
      printf("Enter an integer value: ");
      scanf("%d", &array[count]);
   }                                                                                                                                                                                                                                                                           

   // Call the function and display the return value.
   printf("\n\nLargest value = %d\n", largest(ptr, MAX));
    printf("\n\nSmallest value = %d\n", least(ptr, MAX));

   return 0;
}


int largest(int *num_array, int length)
{
   int count, biggest = num_array[0];

   for ( count = 0; count < length; count++)
   {
      if (num_array[count] > biggest)
        biggest = num_array[count];
   }

   return biggest;
}

int least(int num_array[], int length)
{
   int count, smallest = num_array[0];

   for ( count = 0; count < length; count++)
   {
      if (num_array[count] < smallest)
        smallest = num_array[count];
   }

   return smallest;
}

作者: 冰血封情    时间: 2005-3-10 16:26

复制内容到剪贴板
代码:
//Passing an array to a function. Alternative way

#include <stdio.h>

#define MAX 10

int array[MAX+1], count;  //这里定义的数组多加了一个单位

int largest(int num_array[]);  //函数原形可以看见 这里只传了一个参数

int main( void )
{

   for (count = 0; count < MAX; count++)
   {
      printf("Enter an integer value: ");
      scanf("%d", &array[count]);

      if ( array[count] == 0 )
        count = MAX;          //if 0 then will exit for loop
   }
   array[MAX] = 0;  //如果用户没输入0 那么就完成循环后把最后一个放0

   //Call the function and display the return value
   printf("\n\nLargest value = %d\n", largest(array));

   return 0;
}

int largest(int num_array[])
{
   int count, biggest = -12000;

   for ( count = 0; num_array[count] != 0; count++)  //检测是否是0
   {
      if (num_array[count] > biggest)
        biggest = num_array[count];  //比大小的循环
   }

   return biggest;
}

作者: 冰血封情    时间: 2005-3-10 16:26

复制内容到剪贴板
代码:
#include <stdio.h>

int x[5] = {1, 2, 3, 4, 5};
int y[5] = {1, 2, 3, 4, 5};
int max;

int sumarrays(int a[], int b[]);

int main(void)
{
    max = sumarrays(x, y);  //错在这里 不能重复定义整型

    printf("%d\n", max);

    return 0;
}

int sumarrays(int a[], int b[])  //错在这里 傻了吧唧加分号
{
    int count, max1 = 0;  //这里用max也不错 因为max是全局变量

    for( count = 0; count < 5; count++ )
    {
        max1 += a[count];
        max1 += b[count];
    }
    return max1;
}
复制内容到剪贴板
代码:
//还没学会怎么把这题中的函数计算结果传给主函数 以便主函数中打印
#include <stdio.h>

int x[5] = {1, 2, 3, 4, 5};
int y[5] = {1, 2, 3, 4, 5};

void sumarrays(int a[], int b[]);

int main(void)
{
    sumarrays(x, y);
    return 0;
}

void sumarrays(int a[], int b[])
{
    int count, max[5];

    for( count = 0; count < 5; count++ )
    {
        max[count] = a[count] + b[count];
        printf("max[%d] is %d!\n", count, max[count]);
    }
}

作者: 冰血封情    时间: 2005-3-10 16:26

复制内容到剪贴板
代码:
//fflush函数练习
#include <stdio.h>
#include <string.h>

int main(void)
{
    FILE *stream1;
    FILE *stream2;

    char buf[50];
    char readbuf[50];
    char *text = "This is a test for fflush function!";

        readbuf[0] = 0;
    printf("Please input a file path to open: ");  //提示用户输入要打开的文件的路径
    scanf("%s", buf);

    stream1 = fopen(buf, "w");  //以可写方式打开
    stream2 = fopen(buf, "r");  //以只读方式打开
    if (stream1 == NULL)  //打开失败
        perror("fdopen failed!");  //失败的报错内容
    else  //打开成功
    {
        fwrite(text, strlen(text)+1, 1, stream1);  //写入字符串 但是由于有缓存 字符串并没有真正的写到文件
        fread(readbuf, 50, 1, stream2);
        printf("Before fflush function: %s\n", readbuf);  //读取文件内容时将发现是空的

        fflush(stream1);  //使用fflush刷新缓存 将文件内容真正写入
        fread(readbuf, 50, 1, stream2);
        printf("After fflush function: %s\n", readbuf);  //这个时候才会看到有正确的结果

        fclose(stream1);  //关闭文件 释放资源
        fclose(stream2);
    }
    return 0;
}

作者: 冰血封情    时间: 2005-3-10 16:27

allocate后显示字符串 然后写到txt
复制内容到剪贴板
代码:
//Demonstrates the use of malloc() to allocate storage by 冰血封情[E.S.T]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char count, *ptr, *p;  //全局变量 大程序千万别瞎JB定义

int main(void)
{
    FILE * files;  //这是我后面为了检查 想写到文本里另外声名的文件指针
    char buf[27];  //27个字符的缓冲区 应该不可以再小 没检查溢出

    if ((ptr = (char *) malloc( 27 * sizeof(char) )) == NULL)  //定义正好够的 原来题目是35 不容易看出问题的本质 小于27出错 但是可以顺利编译
    {
        puts("Memory allocation error.");
        return 1;  //报错后返回值
    }

    p = ptr;  //保证ptr不变好打印和写入

    for (count = 65; count < 91; count++)  //循环储存
        *p++ = count;  //把数字存储到p所指的文件中
    *p = &#39;\0&#39;;

    //Display the string on the screen

    puts(ptr);  //显示要写入的内容
    puts(p);  //显示那个恶心的空字符

    printf("Please input a file path to open: ");  //提示用户输入要打开的文件的路径
    scanf("%s", buf);  //将文件地址存储到buf里
    files = fopen(buf, "w");  //以可写方式打开
    if (files == NULL)  //打开失败
        perror("fopen failed!");  //失败的报错内容
    else //打开成功
    {
        fwrite(ptr, strlen(ptr), 1, files);  //原来我错在用p写 p都是到空符号了 还tmd写个屁
    }
    fclose(files);  //释放资源打开的文件
    free(ptr);  //释放资源

    return 0;
}

作者: 冰血封情    时间: 2005-3-10 16:27

两种声明空间存储的方法:
数组
复制内容到剪贴板
代码:
#include <stdio.h>

int main(void)
{
    char input[80];

    puts("input a char for the fucking gliet!");
    gets(input);
   
    printf("You input the \" %s \" for fuck!\n", input);  //起初竟然把%s错写成%c 咋这么贱呢
    puts("You fucked pretty good boy!");

    return 0;
}
传说中的随机分配
复制内容到剪贴板
代码:
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    char *ptr;

    ptr = (char *) malloc ( 80 * sizeof (char));
    puts("Hill. Do you wanna fuck gliet: ");
    gets(ptr);
    puts("Ok! I will use the fuction puts to show you what you wrote: ");
    puts(ptr);
    free(ptr);

    return 0;
}
题目要求写一个拷贝字符数组的程序
复制内容到剪贴板
代码:
//大胆使用strcpy来完成 没学呢 只因为前几天有个例子用过一次
//没想到我这么SB的人也可以成功
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    char *ptr, string[256];

    ptr = (char *) malloc ( 80 * sizeof (char));
    puts("Hill. Do you wanna fuck gliet: ");
    gets(ptr);
    puts("Ok! I will use the fuction puts to show you what you wrote: ");
    puts(ptr);

    strcpy( string, ptr );
    puts(string);
    free(ptr);

    return 0;
}

作者: 冰血封情    时间: 2005-3-10 16:28

复制内容到剪贴板
代码:
//接受用户输入的两个字符串做参数
//返回比较长的那个字符串 并且打印
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char * longger( char x[], char y[] );  //函数原型 接受两个指针返回一个指针

int main(void)
{
    char *ptr, x1[10], y1[10];

    puts("Hill. Do you wanna fuck gliet?");
    puts("Input 2 words to fuck: ");

    scanf("%s%s", x1, y1);  //接受两个字符串

    ptr = longger( x1, y1 );  //调用字函数比较长度 顺便接受反馈的指针

    puts("Ok! I will use the fuction puts to show you what you wrote the longer one: ");
    puts(ptr);  //打印长的那个

    return 0;
}

char *  longger( char x[], char y[] )  //x[] y[]都是指针型 这样写是为了看清楚指向数组
{
    if (  strlen(x) > strlen(y) )  //使用strlen比较长度
        return x;  //谁长就把谁的第一个字符的位置反馈回去
    else
        return y;
}
复制内容到剪贴板
代码:
//接受用户输入的两个字符串做参数
//返回接在一起的字符串 并且打印
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char * longger( char x[], char y[] );  //函数原型 接受两个指针返回一个指针

int main(void)
{
    char *ptr, x1[10], y1[10];

    puts("Hill. Do you wanna fuck gliet?");
    puts("Input 2 words to fuck: ");

    scanf("%s%s", x1, y1);  //接受两个字符串

    ptr = longger( x1, y1 );  //调用字函数比较长度 顺便接受反馈的指针

    puts("Ok! I will use the fuction puts to show you what you wrote the longer one: ");
    puts(ptr);  //打印长的那个

    return 0;
}

char *  longger( char x[], char y[] )  //x[] y[]都是指针型 这样写是为了看清楚指向数组
{
    /* if (  strlen(x) > strlen(y) )  //使用strlen比较长度
        return x;  //谁长就把谁的第一个字符的位置反馈回去
    else
        return y; */
    char *ptr1;  //声明一个函数内用的指针
    ptr1 = (char *) malloc (20 * sizeof(char));  //分配空间为第三个字符串
    ptr1 = strcat( x, y );
    printf("%s", ptr1);
    printf("%s", x);
    free(ptr1);

    return ptr1;
}

作者: 冰血封情    时间: 2005-3-10 16:28

简单结构
复制内容到剪贴板
代码:
#include <stdio.h>

int length, width;
long area;

struct coord{
    int x;
    int y;
};

struct rectangle{
    struct coord topleft;
    struct coord bottomrt;
} mybox;

int main(void)
{
    printf("top left x: ");
    scanf("%d", &mybox.topleft.x);

    printf("top left y: ");
    scanf("%d", &mybox.topleft.y);

    printf("bottom right left x: ");
    scanf("%d", &mybox.bottomrt.x);

    printf("bottom right left y: ");
    scanf("%d", &mybox.bottomrt.y);

    width = mybox.bottomrt.x - mybox.topleft.x;
    length = mybox.bottomrt.y - mybox.topleft.y;

    area = width * length;
    printf("\nThe area is %ld units.\n", area);

    return 0;
}

作者: 冰血封情    时间: 2005-3-13 05:11

数组包含结构
复制内容到剪贴板
代码:
//终于进入结构的学习了
#include <stdio.h>

struct entry {
    char fname[20];
    char lname[20];
    char phone[10];
}list[4];

int i;

int main(void)
{
    for(i = 0; i < 4; i++)
    {
        printf("Enter first name: ");
        scanf("%s", list[i].fname);
        printf("Enter last name: ");
        scanf("%s", list[i].lname);
        printf("Enter phone in 123-4567 format: ");
        scanf("%s", list[i].phone);
    }

    printf("\n\n");

    for (i = 0; i < 4; i++)
    {
        printf("Name: %s %s", list[i].fname, list[i].lname);
        printf("\t\tPhone: %s\n", list[i].phone);
    }

    return 0;
}

作者: 冰血封情    时间: 2005-3-13 06:14

复制内容到剪贴板
代码:
//本来考虑用指针代替name的 后来不行 因为指针必须初始化 否则很危险
//如果没初始化我直接把内容给他 那就不知道他放到什么地方去了
#include <stdio.h>

#define MAX 4

struct part {
    short number;
    char name[10];
} data[MAX] = {1, "Smith", 2, "Jones", 3, "Adams", 4, "Wilson"};

struct part *p_part;
int count;

int main(void)
{
    p_part = data;

    for( count = 0; count < 4; count++)
    {
        printf("At address %d: %d %s\n", p_part, p_part->number, p_part->name);
        p_part++;
    }

    return 0;
}

作者: 冰血封情    时间: 2005-3-16 01:31

复制内容到剪贴板
代码:
//系统命令调用练习
//一个小程序 省去打命令的辛苦哟 by 冰血封情
#include <stdio.h>
#include <stdlib.h>

int menu(void);

int main(void)
{
     char input0[] = "ping [url]www.bbnl.org[/url]";
     char input1[] = "netstat -an";
     char input2[] = "tasklist";

     int x;

     x = menu();

     while (x > 1 || x < 4)
     {

          switch(x)
          {
          case 1:
              {
                   puts("Now pinging [url]www.bbnl.org:[/url] ");
                   system(input0);
                   break;
              }
          case 2:
              {
                   puts("Now nestat to c the port: ");
                   system(input1);
                   break;
              }
          case 3:
              {
                   puts("Now run tasklist to c task: ");
                   system(input2);
                   break;
              }
          case 4:
              {
                   puts("Now exit to win program...");
                   exit(0);
              }
          default:
              {
                   puts("Error parameters: ");
              }

          }
          x = menu();
     }

     return 0;
}

int menu(void)
{
     int fx = 0;

     while (fx < 1 || fx > 4)
     {
          printf("This is a program for EvilOctal[E.S.T] private.\n");
          printf("Please input a number between 1 and 4\n");
          printf("\tEnter 1 to ping bbnl ip\n");
          printf("\tEnter 2 to show port list\n");
          printf("\tEnter 3 to show the task\n");
          printf("\tEnter 4 to exit the program\n");
          printf("Enter a munber: ");
          scanf("%d", &fx);

          if (fx < 1 || fx > 4)
              printf("Please input a right parameters: \n");
     }
     return fx;
}
晕自己想做来玩的 哈哈 没想到 最后的选做题竟然和这个一样 省了
作者: 冰血封情    时间: 2005-3-16 05:38

复制内容到剪贴板
代码:
#include <stdio.h>
#include <stdlib.h>

/*
int inc(int x, int y);
int dec(int x, int y);
int mul(int x, int y);
int div(int x, int y);
printf("");
这个么 是一个可以进行加减乘除运算的小计算器
是13天课程的一个选做题目
以前的选做都做了 此次自然也不例外了
By 冰血封情[E.S.T]
*/
int menu(void);

int main(void)
{
    int count, x, y;

    printf("This is a counter made by EvilOctal[E.S.T]: \n");
    printf("He can help you to finish some simple count.\n");
   
    count = menu();
    while(1)
    {
        switch(count)
        {
        case 1:
            {
                printf("Please input 2 number for inc by space: ");
                scanf("%d %d", &x, &y);
                printf("\n%d + %d = %d", x, y, (x + y));
                break;
            }
        case 2:
            {
                printf("Please input 2 number for dec by space: ");
                scanf("%d %d", &x, &y);
                printf("\n%d - %d = %d", x, y, (x - y));
                break;
            }
        case 3:
            {
                printf("Please input 2 number for mul by space: ");
                scanf("%d %d", &x, &y);
                printf("\n%d x %d = %d", x, y, (x * y));
                break;
            }
        case 4:
            {
                printf("Please input 2 number for div by space: ");
                scanf("%d %d", &x, &y);
                printf("\n%d / %d = %d", x, y, (x / y));
                break;
            }
        case 5:
            {
                printf("\nOk! You chose EXIT...");
                printf("\nSee you!");
                exit(0);
            }
        default:
            {
                printf("You will never see me in the world!");
            }
        }
        count = menu();
    }
    return 0;
}

int menu(void)
{
    int choose = 0;
   
    while(choose < 1 || choose > 5)
    {
        puts("Choose the number for inc dec mul or div:");
        printf("1 is inc;2 is dec;3 is mul;4 is div;5 to escape\n");
        printf("Please input a number between 1 and 5: ");
        scanf("%d", &choose);
    }
    return choose;
}

作者: 冰血封情    时间: 2005-3-17 04:34

复制内容到剪贴板
代码:
//娘的 这程序看起来短 但是不经意的时候十分容易出问题
#include <stdio.h>

#define MAX 10

int main(void)
{
    char ch, buffer[MAX+1];
    int x = 0; //要注意 这里是从0开始 所以11个只到10

    while ((ch =getchar()) != &#39;\n&#39; && x < MAX) //一次反馈一个ch MAX之后就不管了
        buffer[x++] = ch; //每次存储一个 最后一次x是10

    buffer[x] = &#39;\0&#39;; //把第10个放成空字符

    puts(buffer);
    printf("%s\n", buffer);

    return 0;
}

作者: 落叶树    时间: 2005-3-17 13:32

昨天看了 53楼的调用简单系统命令的第一个char input0[] = "ping www.bbnl.org";
的url要去掉啦,下面的 case 1  输出同理。

54楼的程序声明了几个加减乘除的无用函数但是没有使用.....还有在输出 printf("\n%d + %d = %d", x, y, (x + y)); 的时候最好把\n放后面这样美观点。

还有一点想说说的是53楼的第一个循环判断while (x > 1 || x < 4) 虽然这样是可以执行的但总觉得有点....  menu返回1虽然也能正确判断下面的switch,但个人觉得改为while (x > 0 && x < 5)在逻辑上要严密点。
作者: EvilOctal    时间: 2005-3-19 18:49

引用:
下面是引用evilbogy于2005-03-17 13:32发表的:
昨天看了 53楼的调用简单系统命令的第一个char input0[] = "ping www.bbnl.org";
的url要去掉啦,下面的 case 1  输出同理。

54楼的程序声明了几个加减乘除的无用函数但是没有使用.....还有在输出 printf("n%d + %d = %d", x, y, (x + y)); 的时候最好把n放后面这样美观点。

.......
53楼那个有问题 具体我已经在另外一个程序更正了一下
其实应该是while(1)
用死循环实现
作者: 冰血封情    时间: 2005-3-24 15:23

要开始着手培养阅读代码的能力了
复制内容到剪贴板
代码:
//程序分析
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define MAXLINES 25

int get_lines(char *lines[]);
void sort(char *p[], int n);
void print_strings(char *p[], int n);

char *lines[MAXLINES];  //定义了一个25个元素的指针数组

int main( void )
{
  int number_of_lines;  //输入了多少行

  number_of_lines = get_lines(lines);  //接受字符串输入的函数

  if ( number_of_lines < 0 )  //返回值小于0就说空间分配失败
  {
     puts(" Memory allocation error");
     exit(-1);
  }

  sort(lines, number_of_lines);  //排序函数
  print_strings(lines, number_of_lines);
  return 0;
}

int get_lines(char *lines[])  //接受一个指向数组元素的指针
{
  int n = 0;
  char buffer[80];  //每行最多输入80个字符

  puts("Enter one line at time; enter a blank when done.");

  while ((n < MAXLINES) && (gets(buffer) != 0) && (buffer[0] != &#39;\0&#39;))  //进入循环的条件 必须全部满足
  {
     if ((lines[n] = (char *)malloc(strlen(buffer)+1)) == NULL)  //动态分配空间
        return -1;  //分配失败返回-1
     strcpy( lines[n++], buffer );  //空间分配成功了就把字符串拷贝到数组里
  }
  
  return n;  //n是返回的字符串数量 就是你输入了几行 可以通过printf("%d", n);来验证

}

void sort(char *p[], int n)  //排序函数接受指向数组的指针和行数
{
  int a, b;
  char *x;

  for (a = 0; a < n-1; a++)  //遍历的次数 明显一次只能移动一个单位
  {
     for (b = 0; b < n-1; b++)  //遍历所有字符串一次
     {
        if (strcmp(p[b], p[b+1]) > 0)  //比较首字符的大小
        {
          x = p[b];  //如果前面的比后面的数字大就调换位置 越小越前面么
          p[b] = p[b+1];
          p[b+1] = x;  //x是用来暂时存储的
        }
     }
  }
}

void print_strings(char *p[], int n)  //打印字符串
{
  int count;

  for (count = 0; count < n; count++)
     printf("%s\n", p[count]);
}

作者: 冰血封情    时间: 2005-3-25 00:17

复制内容到剪贴板
代码:
#include <stdio.h>

int main(void)
{
    int a=5, b=7;
    double x=67.8564,y=-789.124;
    char c=&#39;A&#39;;
    long n=1234567;
    unsigned u=65535;

    printf("%d%d\n",a,b);
    printf("%3d%3d\n",a,b);
    printf("%f,%f\n",x,y);
    printf("%-10f,%-10f\n",x,y);
    printf("%8.2f,%8.2f,%.4f,%.4f,%3f,%3f\n",x,y,x,y,x,y);
    printf("%e,%10.2e\n",x,y);
    printf("%c,%d,%o,%x\n",c,c,c,c);
    printf("%ld,%lo,%lx\n",n,n,n);
    printf("%u,%o,%x,%d\n",u,u,u,u);
    printf("%s,%5.3s\n","COMPUTER","COMPUTER");

    return 0;
}

作者: 冰血封情    时间: 2005-3-26 08:30

复制内容到剪贴板
代码:
#include <stdio.h>

int square(int x);

int (*ptr)(int x);

int main(void)
{
    ptr = square;

    printf("%d %d\n", square(6), ptr(7));
    return 0;
}

int square(int x)
{
    return x * x;
}

作者: 冰血封情    时间: 2005-3-26 09:28

  缺点 输入字母死循环 fuck
使用函数指针来调用不同的函数
复制内容到剪贴板
代码:
#include <stdio.h>

void func1(int x);
void one(void);
void two(void);
void other(void);

int main(void)
{
     int nbr;

     for(;;)
     {
          puts("Enter an integer between 1 and 10, 0 to exit:");
          scanf("%d", &nbr);

          if(nbr == 0)
              break;
          func1(nbr);
     }
     return 0;
}

void func1(int x)
{
     void (*ptr)(void);

     if(x == 1)
          ptr = one;
     else if(x == 2)
          ptr = two;
     else
          ptr = other;

     ptr();
}

void one(void)
{
     puts("You entered 1.");
}

void two(void)
{
     puts("You entered 2.");
}

void other(void)
{
     puts("You entered something other than 1 or 2.");
}

作者: 冰血封情    时间: 2005-3-26 10:39

将指针作为参数传递给函数
高级指针真吐血
复制内容到剪贴板
代码:
#include <stdio.h>

void func1(void (*p)(void));  //函数接受一个指向函数的指针
void one(void);
void two(void);
void other(void);

int main(void)
{
     int nbr;
      void (*ptr)(void);  //在函数体里定义的函数指针

     for(;;)  //死循环来处理直到0后退出
     {
          puts("Enter an integer between 1 and 10, 0 to exit:");
          scanf("%d", &nbr);

          if(nbr == 0)  //等于0退出
              break;
              else if(nbr == 1)  //等于1的话
                  ptr = one;  //就把指针指向函数one
              else if(nbr == 2)
                  ptr = two;
              else
                  ptr = other;
          func1(ptr);  //调用函数 传递指针
     }
     return 0;
}

void func1(void (*p)(void))
{
     p();  //通过指针执行相应函数
}

void one(void)
{
     puts("You entered 1.");
}

void two(void)
{
     puts("You entered 2.");
}

void other(void)
{
     puts("You entered something other than 1 or 2.");
}

作者: EvilOctal    时间: 2005-3-26 14:02

  字符串排序
复制内容到剪贴板
代码:
/* Inputs a list of strings from the keyboard, sorts them, */
/* and then displays them on the screen. */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define MAXLINES 25

int get_lines(char *lines[]);
void sort(char *p[], int n);
void print_strings(char *p[], int n);

char *lines[MAXLINES];

int main( void )
{
  int number_of_lines;

  /* Read in the lines from the keyboard. */

  number_of_lines = get_lines(lines);

  if ( number_of_lines < 0 )
  {
     puts(" Memory allocation error");
     exit(-1);
  }

  sort(lines, number_of_lines);
  print_strings(lines, number_of_lines);
  return 0;
}

int get_lines(char *lines[])
{
  int n = 0;
  char buffer[80];  /* Temporary storage for each line. */

  puts("Enter one line at time; enter a blank when done.");

  while ((n < MAXLINES) && (gets(buffer) != 0) &&
       (buffer[0] != &#39;\0&#39;))
  {
     if ((lines[n] = (char *)malloc(strlen(buffer)+1)) == NULL)
        return -1;
     strcpy( lines[n++], buffer );
  }
  return n;

} /* End of get_lines() */

void sort(char *p[], int n)
{
  int a, b;
  char *x;

  for (a = 1; a < n; a++)
  {
     for (b = 0; b < n-1; b++)
     {
        if (strcmp(p[b], p[b+1]) > 0)
        {
          x = p[b];
          p[b] = p[b+1];
          p[b+1] = x;
        }
     }
  }
}

void print_strings(char *p[], int n)
{
  int count;

  for (count = 0; count < n; count++)
     printf("%s\n", p[count]);
}
函数指针实现 直接通过指针调用
复制内容到剪贴板
代码:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define MAXLINES 25

int get_lines(char *lines[]);

void sort1(char *p[], int n);
void sort2(char *p[], int n);
void print_strings(char *p[], int n);

char *lines[MAXLINES];

int main( void )
{
  int number_of_lines, x;
  void (*ptr)(char *p[], int n);  //定义在这里没有问题的

  number_of_lines = get_lines(lines);

  if ( number_of_lines < 0 )
  {
     puts(" Memory allocation error");
     exit(-1);
  }
  printf("Forward 1, Backword 2: ");
  scanf("%d", &x);

  if(x == 1)
  {
       ptr = sort1;  //原来我这SB竟然把整个函数连同参数部分都写右边了
  }
  else if(x == 2)
  {
       ptr = sort2;
  }
  ptr(lines, number_of_lines);  //原来我这SB竟然直接调用没给参数
  print_strings(lines, number_of_lines);
  return 0;
}

int get_lines(char *lines[])
{
  int n = 0;
  char buffer[80];

  puts("Enter one line at time; enter a blank when done.");

  while ((n < MAXLINES) && (gets(buffer) != 0) &&
       (buffer[0] != &#39;\0&#39;))
  {
     if ((lines[n] = (char *)malloc(strlen(buffer)+1)) == NULL)
        return -1;
     strcpy( lines[n++], buffer );
  }
  return n;

}

void sort1(char *p[], int n)
{
  int a, b;
  char *x;

  for (a = 1; a < n; a++)
  {
     for (b = 0; b < n-1; b++)
     {
        if (strcmp(p[b], p[b+1]) > 0)
        {
          x = p[b];
          p[b] = p[b+1];
          p[b+1] = x;
        }
     }
  }
}

void sort2(char *p[], int n)
{
  int a, b;
  char *x;

  for (a = 1; a < n; a++)
  {
     for (b = 0; b < n-1; b++)
     {
        if (strcmp(p[b], p[b+1]) < 0)
        {
          x = p[b];
          p[b] = p[b+1];
          p[b+1] = x;
        }
     }
  }
}

void print_strings(char *p[], int n)
{
  int count;

  for (count = 0; count < n; count++)
     printf("%s\n", p[count]);
}
将指针做为参数传递给函数 其实我都可以做到 只是麻烦 也是第一个函数修改的 不过这个是我自己修改的 后面可以看见书上修改的 可以对比
复制内容到剪贴板
代码:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define MAXLINES 25

int get_lines(char *lines[]);

void func1(void (* ptr_p)(char *p[], int n));
void sort1(char *p[], int n);
void sort2(char *p[], int n);
void print_strings(char *p[], int n);

char *lines[MAXLINES];
int number_of_lines;  //子函数要用 所以全局了

int main( void )
{
  int x;
  void (*ptr)(char *p[], int n);

  number_of_lines = get_lines(lines);

  if ( number_of_lines < 0 )
  {
     puts(" Memory allocation error");
     exit(-1);
  }
  printf("Forward 1, Backword 2: ");
  scanf("%d", &x);

  if(x == 1)
  {
       ptr = sort1;  //原来我这SB竟然把整个函数连同参数部分都写右边了
  }
  else if(x == 2)
  {
       ptr = sort2;
  }
  func1(ptr);
  print_strings(lines, number_of_lines);
  return 0;
}

void func1(void (* ptr_p)(char *p[], int n))
{
     ptr_p(lines, number_of_lines);  //在这里卡了很长时间 闹了半天参数作用域要全局 我操 那我还用你干个P
}

int get_lines(char *lines[])
{
  int n = 0;
  char buffer[80];

  puts("Enter one line at time; enter a blank when done.");

  while ((n < MAXLINES) && (gets(buffer) != 0) &&
       (buffer[0] != &#39;\0&#39;))
  {
     if ((lines[n] = (char *)malloc(strlen(buffer)+1)) == NULL)
        return -1;
     strcpy( lines[n++], buffer );
  }
  return n;

}

void sort1(char *p[], int n)
{
  int a, b;
  char *x;

  for (a = 1; a < n; a++)
  {
     for (b = 0; b < n-1; b++)
     {
        if (strcmp(p[b], p[b+1]) > 0)
        {
          x = p[b];
          p[b] = p[b+1];
          p[b+1] = x;
        }
     }
  }
}

void sort2(char *p[], int n)
{
  int a, b;
  char *x;

  for (a = 1; a < n; a++)
  {
     for (b = 0; b < n-1; b++)
     {
        if (strcmp(p[b], p[b+1]) < 0)
        {
          x = p[b];
          p[b] = p[b+1];
          p[b+1] = x;
        }
     }
  }
}

void print_strings(char *p[], int n)
{
  int count;

  for (count = 0; count < n; count++)
     printf("%s\n", p[count]);
}
下面是书上写的 我详细阅读加了注释
复制内容到剪贴板
代码:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define MAXLINES 25

int get_lines(char *lines[]);  //管理输入的函数
void sort(char *p[], int n, int sort_type);  //排序
void print_strings(char *p[], int n);  //打印字符的函数
int alpha(char *p1, char *p2);  //顺序排列
int reverse(char *p1, char *p2);  //反序排列

char *lines[MAXLINES];  //字符型指针数组

int main( void )
{
  int number_of_lines, sort_type;

  number_of_lines = get_lines(lines);  //调用函数输入

  if ( number_of_lines < 0 )  //如果返回值小于0
  {
     puts("Memory allocation error");  //报错并退出
     exit(-1);
  }

  puts("Enter 0 for reverse order sort, 1 for alphabetical:" );  //0反序1顺序
  scanf("%d", &sort_type);  //输入值

  sort(lines, number_of_lines, sort_type);  //调用排序的函数 传递行数
  print_strings(lines, number_of_lines);  //把函数和行书传递过去打印 打印排列好的字符串
  return 0;  //返回
}

int get_lines(char *lines[])  //输入函数
{
   int n = 0;
   char buffer[80];

   puts("Enter one line at time; enter a blank when done.");

   while (n < MAXLINES && gets(buffer) != 0 && buffer[0] != &#39;\0&#39;)  //输入的条件 gets()的返回值以前学过
   {
      if ((lines[n] = (char *)malloc(strlen(buffer)+1)) == NULL)  //为每行字符传分配空间
      return -1;  //分配空间出错返回的值
      strcpy( lines[n++], buffer );  //成功则把字符串拷贝进空间 然后n++ 继续循环直到退出
   }
   return n;  //反回n的值

}

void sort(char *p[], int n, int sort_type)  //接受一个指针数组指针 行数 和排序的类型
{
   int a, b;
   char *x;

   int (*compare)(char *s1, char *s2);  //定义一个指向指针的函数

  compare = (sort_type) ? reverse : alpha;  //通过判断来决定是使指针指向哪个函数

   for (a = 1; a < n; a++) //n-1次循环
   {
      for (b = 0; b < n-1; b++)  //两层循环才能完成所有的排序 这行是确定从头到尾遍历一次
      {
        if (compare(p[b], p[b+1]) > 0)  //调用前面指向的函数
        {
           x = p[b];  //用x来做中转
           p[b] = p[b+1];  //如果是满足条件就交换
           p[b+1] = x;
        }
      }
   }
}

void print_strings(char *p[], int n)  //n是接受的行数 p是指针数组
{
   int count;  //定义循环的次数

   for (count = 0; count < n; count++)  //因为n行 所以从0到n-1
      printf("%s\n", p[count]);  //直接调用接受的参数打印
}

int alpha(char *p1, char *p2)  //比较函数 接受两个数组指针 顺序排列
{
   return(strcmp(p2, p1));  //进行比较
}

int reverse(char *p1, char *p2)  //反序排列 接受的都一样是没关系的
{
    return(strcmp(p1, p2));  //其实都是传给它 只不过是谁减谁而已
}

作者: 冰血封情    时间: 2005-4-2 01:18

  链表的基础
复制内容到剪贴板
代码:
#include <stdio.h>
#include <stdlib.h>

#ifndef NULL
  #define NULL 0  //检查是否定义了NULL 如果没有就将其定义为0
#endif

struct list  //定义一个结构
{
  int   ch;  //结构成员
  struct list *next_rec;  //链表指针
};


typedef struct list LIST;
typedef LIST *LISTPTR;  //指向LIST结构类型的指针

//函数原型
LISTPTR add_to_list( int, LISTPTR );
void show_list(LISTPTR);
void free_memory_list(LISTPTR);

int main( void )
{
  LISTPTR first = NULL;  //首先把首指针初始化
  int i = 0;
  int ch;
  char trash[256];

  while ( i++ < 5 )  //输入5次 先比较后加加 ++优先级是高 但是要看在前在后
  {
    ch = 0;
    printf("\nEnter character %d: ", i);

    do
    {
       printf("\nMust be a to z: ");
       ch = getc(stdin);  //读取一个字符
       gets(trash);  //把余下的字符处理掉 但是有溢出隐患
    } while( (ch < &#39;a&#39; || ch > &#39;z&#39;) && (ch < &#39;A&#39; || ch > &#39;Z&#39;));  //限制字母必须的范围

    first = add_to_list( ch, first );  //调用函数实现链表 传给它字母和指针的头
  }

  show_list( first );
  free_memory_list( first );
  return 0;
}

LISTPTR add_to_list( int ch, LISTPTR first )
{
  LISTPTR new_rec = NULL;  //指向要加入的新节点
  LISTPTR tmp_rec = NULL;  //指向当前的节点
  LISTPTR prev_rec = NULL;  //指向当前节点的前一个节点

  new_rec = (LISTPTR)malloc(sizeof(LIST));  //为新节点分配空间
  if (!new_rec)  //如果是空 非了就是1
  {
    printf("\nUnable to allocate memory!\n");
    exit(1);  //报错并退出
  }

  new_rec->ch = ch;  //成功分配空间后 先把ch给新节点的ch
  new_rec->next_rec = NULL;  //新节点的指针先放空

  if (first == NULL)  //如果第一个节点等于空
  {
     first = new_rec;  //第一个节点就是新节点
     new_rec->next_rec = NULL;  //但是新节点的下面还是没有东西
  }
  else  //如果新节点不为空 那就是原来有东西
  {
    if ( new_rec->ch < first->ch )  //看看节点内容谁大 谁就靠后
    {
      new_rec->next_rec = first;  //如果原来的大 新来的就指向原来的 保证链表不丢失
      first = new_rec;  //而新的就是在第一个了
    }
    else  //如果原来的小
    {
      tmp_rec = first->next_rec;  //那就把原来的下一个指针指向一个当前节点
      prev_rec = first;  //把头给当前节点的上一个节点

      if ( tmp_rec == NULL )  //当前节点如果是空的
      {
         prev_rec->next_rec = new_rec;  //而前一个节点的指针指向新来的
      }
      else  //非空
      {
        while (( tmp_rec->next_rec != NULL))  //当下面也不为空
        {
          if( new_rec->ch < tmp_rec->ch )  //就把新的和下面的比 如果当前的大
          {
            new_rec->next_rec = tmp_rec;  //那么当前的就放到后面去了
            if (new_rec->next_rec != prev_rec->next_rec)  //如果指针指向的地址不等就报错
            {
              printf("ERROR");
              getc(stdin);
              exit(0);
            }
            prev_rec->next_rec = new_rec;  //则前一个的指针指向新的
            break;
          }
          else  //如果当前的小 则说明应该放到后面
          {
            tmp_rec = tmp_rec->next_rec;  //分别将指针指向下面的节点
            prev_rec = prev_rec->next_rec;  //这里真是多亏了书上的注释 被卡住了
          }
        }
        if (tmp_rec->next_rec == NULL)  //如果下面为空了 那么就到末尾了
        {
          if (new_rec->ch < tmp_rec->ch )  //如果新来的应该在末尾的前面
          {
            new_rec->next_rec = tmp_rec;  //那么就把新的指针指向末尾的头
            prev_rec->next_rec = new_rec;  //把前面一个的指针指向新来的
          }
          else  //如果比原来所有的都大
          {
            tmp_rec->next_rec = new_rec;  //那就应该放到末尾
            new_rec->next_rec = NULL;  //下面就是空空了
          }
        }
      }
    }
  }
  return(first);  //排序完成后把链表头返回
}

void show_list( LISTPTR first )  //可以看到函数接受整个链表
{
  LISTPTR cur_ptr;  //定义一个当前节点
  int counter = 1;  //用来计数

  printf("\n\nRec addr  Position  Data  Next Rec addr\n");
  printf("========  ========  ====  =============\n");

  cur_ptr = first;  //把接受到的链表头给指针
  while (cur_ptr != NULL )  //如果不等于空
  {
    printf("    %X    ", cur_ptr );
    printf("%2d     %c", counter++, cur_ptr->ch);
    printf("    %X  \n",cur_ptr->next_rec);
    cur_ptr = cur_ptr->next_rec;  //轮番打印直到结尾
  }
}


void free_memory_list(LISTPTR first)  //接受链表释放空间
{
  LISTPTR cur_ptr, next_rec;  //和刚才一样
  cur_ptr = first;  //先找到链表头

  while (cur_ptr != NULL)  //遍历
  {
    next_rec = cur_ptr->next_rec;
    free(cur_ptr);  //打印完了 要释放内存的
    cur_ptr = next_rec;
  }
}

作者: 冰血封情    时间: 2005-4-7 21:36

作业6.1 最大公约 和最小公倍
复制内容到剪贴板
代码:
#include <stdio.h>
#include <stdlib.h>

int submultiple(int x, int y);
int multiple(int x, int y);

int count = 0;

int main(void)
{
int a = 0, b = 0;
int sm = 0, mm = 0;

printf("Please input 2 number by space: ");
scanf("%d %d", &a, &b);

printf("Select the list!\n");
printf("\tSubmultiple is 1, Multiple is 2, please select one: ");
scanf("%d", &count);

if ( count == 1 )
{
       sm = submultiple(a, b);
       if ( sm == -1 )
       {
        printf("Exit!");
        exit (1);
       }
       printf("submutiple is %d!", sm);
}
else if ( count == 2 )
{
       mm = multiple(a, b);
       if ( mm == -1 )
       {
        printf("Exit!");
        exit (1);
       }
       printf("mutiple is %d!", mm);
}
else
{
       printf("Error input!");
       exit (1);
}
getchar();
return 0;
}

int submultiple(int x, int y)
{
for(count = ( x >= y ? y : x ); count > 0; count --)
{
       if ( x % count == 0 && y % count == 0 )
        return count;
}
printf("No submultiple!\n");
return (-1);
}

int multiple(int x, int y)
{
for( count = 1; count <= ( x * y ); count++ )
{
       if ( count % x == 0 && count % y==0 )
        return count;
}
printf("No multiple!\n");
return (-1);
}
作业6.3 求 a+aa+aaa+aaaa+.....+aaaaaaaaaaaaaaaaaaaaaaaaaaaa 多少个a可以自己定义
复制内容到剪贴板
代码:
#include <stdio.h>
#include <math.h>

int main(void)
{
int a = 0, n = 0, i = 0;
double x = 0, s = 0;

printf("Please input a and n separate by space: ");
scanf("%d %d", &a, &n);

for(;i < n; i++ )
{
x = x + a * (pow( 10, i));
s += x;
}

printf("%f", s);
return 0;
}
作业6.8 求2/1+3/2+5/3+8/5+....求前20项的和 我只求前6
复制内容到剪贴板
代码:
#include <stdio.h>

int main(void)
{
float f1 = 1, f2 = 2, f3 = 3, f4 = 0, s = 0;

for(int i = 0; i < 3; i++ )
{
f4 = (f2/f1) + (f3/f2);
s += f4;
f1 = f3;
f2 = f2 + f3;
f3 = f1 + f2;
}
f4 = (2.0/1)+(3.0/2)+(5.0/3)+(8.0/5)+(13.0/8)+(21.0/13);  //验证用
printf("%f\n", s);
printf("%f\n", f4);  //验证用
return 0;
}

作者: 冰血封情    时间: 2005-4-7 22:49

6.11
复制内容到剪贴板
代码:
#include <stdio.h>
#include <math.h>
void main()
{ float a,x0,x1;
printf("Enter a positive number:");
scanf("%f",&a);
x0=10;
x1=(x0+a/x0)/2;
do
{ x0=x1;
x1=(x0+a/x0)/2;
}while(fabs(x0-x1)>=1e-5);
printf("The square root of %5.2f is %8.5f\n",a,x1);
}

作者: 冰血封情    时间: 2005-4-10 16:29

复制内容到剪贴板
代码:
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    FILE *fp;  //文件指针
    char ch, filename[40], mode[4];
   
    while (1)
    {
        printf("Enter a filename: ");
        gets(filename);  //读入文件名
        printf("Enter a mode (max 3 characters): ");
        gets(mode);  //读入模式

        if( (fp = fopen( filename, mode )) != NULL )  //打开并且检测是否失败
        {
            printf("Successful opening %s in mode %s.\n", filename, mode);
            fclose(fp);  //关闭文件
            puts("Enter x to exit, any other to continue: ");
            if( (ch = getc(stdin)) == &#39;x&#39;)  //读取x后结束
                break;
            else
                continue;
        }
        else
        {
            fprintf(stderr, "Error opening file %s in mode %s.\n", filename, mode);
            puts("Enter x to exit, any other to try again: ");
            if( (ch = getc(stdin)) == &#39;x&#39;)
                break;
            else
                continue;
        }
    }
    return 0;
}

作者: 冰血封情    时间: 2005-4-10 19:18

复制内容到剪贴板
代码:
#include <stdio.h>
#include <stdlib.h>


void clear_kb(void);

int main(void)
{
    FILE *fp;  //文件指针
    float data[5];  //数组 用来存储5个浮点数字
    int count;  //循环用
    char filename[20];  //文件名字

    puts("Enter 5 floating-point numerical values.");

    for(count = 0; count <5; count ++)
        scanf("%f", &data[count]);

    clear_kb();  //清理多余的字符

    puts("Enter a name for the file.");
    gets(filename);

    if( (fp = fopen(filename, "w")) == NULL)  //可写方式打开 否则不可以写
    {
        fprintf(stderr, "Error opening file %s.\n", filename);  //输出错误
        exit(1);
    }

    for (count = 0; count < 5; count++)
    {
        fprintf(fp, "data[%d] = %f\n", count, data[count]);
        fprintf(stdout, "data[%d] = %f\n", count, data[count]);
    }
    fclose(fp);  //关闭文件
    printf("\n");
    return 0;
}

void clear_kb(void)
{
    char junk[80];  //局部变量 重复调用可以用来清理那些多余的字符
    gets(junk);
}

作者: 冰血封情    时间: 2005-4-10 19:46

如果下面的程序你这样输入:
1.1 1.1 1.1 1.1 1.1 fuck.txt<回车>
可以一次解决
复制内容到剪贴板
代码:
#include <stdio.h>
#include <stdlib.h>


//void clear_kb(void);

int main(void)
{
     FILE *fp;  //文件指针
     float data[5];  //数组 用来存储5个浮点数字
     int count;  //循环用
     char filename[20];  //文件名字

     puts("Enter 5 floating-point numerical values.");

     for(count = 0; count <5; count ++)
          scanf("%f", &data[count]);

     //clear_kb();  //清理多余的字符

     puts("Enter a name for the file.");
     gets(filename);

     if( (fp = fopen(filename, "w")) == NULL)  //可写方式打开 否则不可以写
     {
          fprintf(stderr, "Error opening file %s.\n", filename);  //输出错误
          exit(1);
     }

     for (count = 0; count < 5; count++)
     {
          fprintf(fp, "data[%d] = %f\n", count, data[count]);
          fprintf(stdout, "data[%d] = %f\n", count, data[count]);
     }
     fclose(fp);  //关闭文件
     printf("\n");
     return 0;
}

/*
void clear_kb(void)
{
     char junk[80];  //局部变量 重复调用可以用来清理那些多余的字符
     gets(junk);
}
*/

作者: 冰血封情    时间: 2005-4-10 20:12

复制内容到剪贴板
代码:
/* Reading formatted file data with fscanf(). */
#include <stdlib.h>
#include <stdio.h>

int main( void )
{
  float f1, f2, f3, f4, f5;
  FILE *fp, *fp1;

   if ( (fp = fopen("fuck.txt", "r")) == NULL)
   {
      fprintf(stderr, "Error opening file.\n");
      exit(1);
   }
    if ( (fp1 = fopen("fuck1.txt", "w")) == NULL)
   {
      fprintf(stderr, "Error opening file.\n");
      exit(1);
   }

   fscanf(fp, "%f %f %f %f %f", &f1, &f2, &f3, &f4, &f5);  //读取
   printf("The values are %f, %f, %f, %f, and %f.\n", f1, f2, f3, f4, f5);  //显示
    fprintf(stdout, "The values are %f, %f, %f, %f, and %f.\n", f1, f2, f3, f4, f5);  //显示
    fflush(stdin);  //没效果的
    fprintf(fp1, "The values are %f, %f, %f, %f, and %f.\n", f1, f2, f3, f4, f5);  //写

   fclose(fp);
    fclose(fp1);
   return 0;
}

作者: 冰血封情    时间: 2005-4-15 13:51

训练阅读能力 小程序基本可以推断正确了
复制内容到剪贴板
代码:
#include <stdlib.h>
#include <stdio.h>

#define BUFLEN 6  //宏定义

char msg[] = "abcdefghijklmnopqrstuvwxyz";  //先定义好字符串

int main( void )
{
   FILE *fp;  //文件指针
   char buf[BUFLEN];  //大小看上面

   if ( (fp = fopen("TEXT.TXT", "w")) == NULL)  //以写方式打开
   {
      fprintf(stderr, "Error opening file.");
      exit(1);
   }

   if (fputs(msg, fp) == EOF)  //写那上面一长串进去
   {
      fprintf(stderr, "Error writing to file.");
      exit(1);
   }

   fclose(fp);  //关闭 刷新

   if ( (fp = fopen("TEXT.TXT", "r")) == NULL)  //以读方式打开
   {
      fprintf(stderr, "Error opening file.");
      exit(1);
   }
   printf("\nImmediately after opening, position = %ld", ftell(fp));  //打印现在的地址 因该是0


   fgets(buf, BUFLEN, fp);  //读5个 0到4
   printf("\nAfter reading in %s, position = %ld", buf, ftell(fp));  //abcde 打印现在的地址应该是5


   fgets(buf, BUFLEN, fp);  //读5个 5到9
   printf("\n\nThe next 5 characters are %s, and position now = %ld", buf, ftell(fp));  //fghij 地址应该是10

   rewind(fp);  //重新弄到开头 不关闭文件直接重置

   printf("\n\nAfter rewinding, the position is back at %ld", ftell(fp));  //应该是0

   fgets(buf, BUFLEN, fp);  //再读5个
   printf("\nand reading starts at the beginning again: %s\n", buf);  //打出刚才的字符串 应该是 abcde
   fclose(fp);  //关闭刷新
   return 0;
}

作者: 冰血封情    时间: 2005-4-15 18:09

真是 还是坐在电脑前面分析东西有灵感
复制内容到剪贴板
代码:
#include <stdlib.h>
#include <stdio.h>

#define MAX 50

int main( void )
{
   FILE *fp;
   int data, count, array[MAX];
   long offset;

   for (count = 0; count < MAX; count++)  //初始化数组
      array[count] = count * 10;

   if ( (fp = fopen("RANDOM.DAT", "wb")) == NULL)  //以可写和二进制方式打开
   {
      fprintf(stderr, "\nError opening file.");
      exit(1);
   }

   if ( (fwrite(array, sizeof(int), MAX, fp)) != MAX)  //写50个int进文件
   {
      fprintf(stderr, "\nError writing data to file.");
      exit(1);
   }
    /*
    getchar();
    fflush(fp);
    */

   fclose(fp);  //关闭刷新

   if ( (fp = fopen("RANDOM.DAT", "rb")) == NULL)  //再用二进制打开读
   {
      fprintf(stderr, "\nError opening file.");
      exit(1);
   }

   while (1) //死循环来实现
   {
      printf("\nEnter element to read, 0-%d, -1 to quit: ",MAX-1);  //问你想看哪个数组元素的内容
      scanf("%ld", &offset);

      if (offset < 0)
        break;
      else if (offset > MAX-1)
        continue;

      if ( (fseek(fp, (offset*sizeof(int)), SEEK_SET)) != 0)
      {
        fprintf(stderr, "\nError using fseek().");
        exit(1);
      }

      fread(&data, sizeof(int), 1, fp);  //就把当前的内容读到data

      printf("\nElement %ld has value %d.", offset, data);
   }

   fclose(fp);
   return 0;
}

作者: 冰血封情    时间: 2005-5-1 17:35

#include <stdio.h>

int main(void)
{
    char *p = "Smile!";
    int x, y;
    for(x = 3; x > 0; x --)
    {
        for(y = 0; y <x; y ++)
        {
            printf("%s", p);
        }
        printf("\n");
    }
    return 0;
}
作者: 冰血封情    时间: 2005-5-4 02:09

  转换文件小写字符成大写
复制内容到剪贴板
代码:
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>  //头文件

void change(FILE *p1, FILE *p2);

int main(int argv, char *argc[])
{
     FILE *fp1, *fp2;

     if(argv != 3)
     {
          fprintf(stderr, "\nCodez by EvilOctal[E.S.T]\n" );
          fprintf(stderr, "Usage: %s <infile> <outfile>", argc[0]);
          exit (0);
     }
     if((fp1 = fopen(argc[1], "r")) == NULL)
     {
          fprintf(stderr, "Error open %s!\nPlease chech the file...\n", argc[1]);
          exit (0);
     }
     if ((fp2 = fopen(argc[2], "w")) == NULL)
     {
          fprintf(stderr, "Error open %s!\nPlease chech the file...\n", argc[2]);
          exit (0);
     }
     change(fp1, fp2);
     fclose(argc[1]);
     fclose(argc[2]);

     return 0;
}

void change(FILE *p1, FILE *p2)
{
     char ch;
     while((ch = fgetc(p1)) != EOF)
     {
          ch = toupper(ch);  //转换函数
          fputc(ch, p2);
     }
}

作者: 冰血封情    时间: 2005-5-4 03:39

统计字符个数
复制内容到剪贴板
代码:
#include <stdio.h>
#include <stdlib.h>

int file_exists(char *filename);  

int main( void )
{
    char ch, source[80];
    int  index;
    long count[127];
    FILE *fp;

    fprintf(stderr, "\nEnter source file name: ");
    gets(source);


    if (!file_exists(source))
    {
        fprintf(stderr, "\n%s does not exist.\n", source);
        exit(1);
    }
    if ((fp = fopen(source, "rb")) == NULL)
    {
        fprintf(stderr, "\nError opening %s.\n", source);
        exit(1);
    }
    for (index = 31; index < 127 ; index++)
        count[index] = 0;

    while ( 1 )
    {
        ch = fgetc(fp);
        if (feof(fp))
            break;
        if (ch > 31 && ch < 127)
            count[ch]++;  //关键的统计过程
    }

    printf("\nChar\t\tCount\n");
    for (index = 32; index < 127 ; index++)
    printf("[%c]\t%d\n", index, count[index]);

    fclose(fp);
    return(0);
}

int file_exists(char *filename)
{
    FILE *fp;
    if ((fp = fopen(filename, "r")) == NULL)
        return 0;
    else
    {
        fclose(fp);
        return 1;
    }
}

作者: 冰血封情    时间: 2005-5-15 19:09

为了考试 真不得不关注细节
复制内容到剪贴板
代码:
#include <stdio.h>
#include <ctype.h>

int main(void)
{
    char f, l, m[80];

    printf("Input first name:");
    scanf("%c", &f);
    fflush(stdin);
    printf("Input last name:");
    scanf("%c", &l);
    fflush(stdin);
    printf("Input middle name:");
    scanf("%s", m);
    fflush(stdin);
    printf("%c. %c.%s", toupper(f), toupper(l), m);

    return 0;
}

作者: 冰血封情    时间: 2005-5-20 03:10

我修改的来源
http://www.cnhacker.com/bbs/read ... page=1&toread=1
复制内容到剪贴板
代码:
#include <stdio.h>

void seqsearch(int p[]);  //直接查抄函数原型
void binsearch(int p[]);  //折半查找函数原型
void bubblesort(int r[]); //起泡无敌风火轮

void menu(void);  //菜单

int ch = 0;  //用全局变量要多加小心 但是这里适合

void menu(void)  //菜单打印
{
    printf("1.seqsearch()\n");
    printf("2.binsearch()\n");
    printf("3.exit()\n");
    printf("please select the method: ");
}

int main(void)
{
    int i = 0, j = 1;
    int a[10];  //用来存放数字的10个元素的数组

    for(i = 0; i < 10; i ++)
      {
          printf("please input the No.%d data: ", i+1);
          scanf("%d", &a[i]);  //依次放入相应的数组元素
      }
    while(j)
    {
            menu();
        scanf("%d", &ch);  //读入菜单选择结果
        switch(ch)
        {
            case 1:
                seqsearch(a);  //是1则调用直接查找函数
                break;
            case 2:
                binsearch(a);  //是2则调用折半查找函数
                break;
            case 3:
                j = 0;  //是3则退出
                break;
            default:
                printf("Error! No %d for select!", ch);  //这里break就是多此一举
        }
        printf("\n");  //晕 还挺注意美观的
    }
    return 0;  //主函数完成 符合C99 表扬
}

void seqsearch(int p[])  //直接查找函数
{
    int i = 0, data = 0;
    printf("please input find data:");  //输入要找的数字
    scanf("%d", &data);  //放到data的内存空间

    while(data != p[i] && i < 10)  //开始一个一个的找
      {
        i ++;
      }
    if(i >= 10)  //如果等于n那就没了
        printf("The data is not found!\n");
    else  //出此以外 那么打印
        printf("the %d position is %d\n", data, i+1);
}

void binsearch(int p[])  //折半法
{
    int data, low = 0, high = 10, mid, find = 0;

    bubblesort(p);  //风火轮排序

    for(data = 0; data < 10; data ++)
        printf("%d ", p[data]);  //循环打印排序后的数组 恐怕不行
      printf("\n");
    printf("please input find data: ");  //输入要找的数字
    scanf("%d", &data);
    while(low <= high && !find)  //如果
    {
        mid = (low + high)/2;
        if(data < p[mid])
            high = mid - 1;
        else if(data > p[mid])
            low = mid + 1;
        else
            find = 1;
    }
    if(!find)  //如果是前面条件导致退出 find必然为0
        printf("the data is not found!\n");
    else  //否则就找到了
        printf("the %d position is %d\n", data, mid+1);
}

void bubblesort(int r[])  //排序程序
{
    int i, j, temp;  //局部变量

    for(j = 0; j < 9; j ++)  //排序
    {
        for(i = 0; i < 9; i ++)
        {
            if(r[i] > r[i + 1])
            {
                temp = r[i];  //交换
                r[i] = r[i + 1];
                r[i + 1] = temp;
            }

        }
    }
   
}





欢迎光临 邪恶八进制信息安全团队技术讨论组 (https://forum.eviloctal.com/) Powered by Discuz! 20100225