标签：
#include<stdio.h>
int main()
{
int shu_zi=0;
printf("请输入一个数:");
scanf("%d",&shu_zi);
switch(shu_zi%2)
{
case 0:
printf("结果为假\n");
break;
case 1:
printf("结果为真\n");
break;
default:
printf("结果不能为负\n");
break;
}
}
#include<stdio.h>
int main()
{
int jia_ge=30,ge_shu=3;
printf("请输入价格和张数:");
scanf("%d%d",&jia_ge,&ge_shu);
if(ge_shu<=0)
{
printf("张数不合理:\n");
}
printf("请输入价格和张数:");
scanf("%d%d",&jia_ge,&ge_shu);
if(ge_shu<=0)
{
printf("张数不合理:\n");
}
printf("请输入价格和张数:");
scanf("%d%d",&jia_ge,&ge_shu);
if(ge_shu<=0)
{
printf("张数不合理:\n");
return 0;
}
printf("总价格是%d\n",jia_ge*ge_shu);
return 0;
}
判断个数
#include<stdio.h>
int main()
{
int jia_ge=0,ge_shu=0;
printf("请输入价格和个数:");
scanf("%d%d",&jia_ge,&ge_shu);
if(0==ge_shu)
{
printf("张数不能为0\n");
}
else if (ge_shu>0)
{
if(0==jia_ge)
{
printf("价格不能为0\n");
}
else if (jia_ge>0)
{
printf("总票价是%d\n",jia_ge*ge_shu);
}
else {
printf("价格不能为负\n");
}
}
else {
printf("张数不能为负\n");
}
return 0;
}
票价终极版：判断次数
#include<stdio.h>
int main()
{
int jia_ge=0, ge_shu=0,xun_huan=0;
for(xun_huan=0;xun_huan<=2;xun_huan++)
{
printf("请输入价格和张数:");
scanf("%d%d",&jia_ge,&ge_shu);
if(ge_shu<=0){
printf("张数不合理\n");
continue;//当张数不合理的情况下立刻进行下一次循环
}
if(jia_ge<=0){
printf("价格不合理\n");
continue;
}
break;//避免价格和张数都合理的情况下再循环
}
if (xun_huan<3){//检查3次是否都输错了
printf("总价格是%d\n",jia_ge*ge_shu);
}
else{
printf("好差劲哦\n");
}
return 0;
}
#include<stdio.h>
int main()
{
int ge_shu=0,xun_huan=0,zhuang_tai=0;
printf("请输入个数:");
scanf("%d",&ge_shu);
for(xun_huan=0;xun_huan<ge_shu;xun_huan++)
{
if(0==zhuang_tai){
printf("她爱我\n");
zhuang_tai=1;//确保相邻两次不一样
}
else if(1==zhuang_tai)
{
printf("她不爱我\n");
zhuang_tai=0;
}
}
return 0;
}
#include<stdio.h>
#include<math.h>
int main()
{
int shu_zi=0,xun_huan=0;
float gen=0;
printf("请输入一个数:");
scanf("%d",&shu_zi);
gen=sqrt(shu_zi);
for(xun_huan=2;xun_huan<=gen;xun_huan++)
{
if(!(shu_zi%xun_huan))//用户给的数字可以整除当前列举的数字,说明不是素数
{
break;
}
}
if(xun_huan<=gen)//根据判断循环没结束
{
printf("数字%d不是素数\n",shu_zi);
}
else //循环结束了
{
printf("数字%d是素数\n",shu_zi);
}
return 0;
}
10到100间的素数
#include<stdio.h>
#include<math.h>
int main()
{
int xun_huan_1=0,xun_huan_2=0;
float gen;
for(xun_huan_1=10;xun_huan_1<=100;xun_huan_1++)//10到100之间的数
{
gen=sqrt(xun_huan_1);
for(xun_huan_2=2;xun_huan_2<=gen;xun_huan_2++)
{
if(!(xun_huan_1%xun_huan_2))//用户给的数字可以整除当前列举的数字,说明不是素数
{
break;
}
}
if(xun_huan_2>=gen)//根据判断循环没结束
{
printf("%d ",xun_huan_1);
}
}
printf("\n");
return 0;
}
#include<stdio.h>
int main()
{
int xun_huan_1=0,xun_huan_2=0;
for(xun_huan_1=1;xun_huan_1<=9;xun_huan_1++)//行循环
{
for(xun_huan_2=1;xun_huan_2<=xun_huan_1;xun_huan_2++)//列循环
{
printf("%d*%d=%d ",xun_huan_1,xun_huan_2,xun_huan_1*xun_huan_2);
}
printf("\n");
}
return 0;
}
#include<stdio.h>
int main()
{
int xun_huan_1=0,xun_huan_2=0,shang_xian=0;
for(xun_huan_1=0;xun_huan_1<10;xun_huan_1++)
{
shang_xian=(200-20*xun_huan_1)/25;//防止负数
for(xun_huan_2=0;xun_huan_2<shang_xian;xun_huan_2++)
{
if(!((200-10*xun_huan_1-25*xun_huan_2)%30))//看30g的面包能买几个
{
printf("10g的面包买%d个，25g的面包买%d个，30g的面包买%d个\n",xun_huan_1,xun_huan_2,(200-10*xun_huan_1-25*xun_huan_2)/30);
}
}
}
return 0;
}
#include<stdio.h>
int main()
{
int shu_zi_1=0,shu_zi_2=0;
printf("请输入一个数:");
scanf("%d",&shu_zi_1);
while(shu_zi_1!=shu_zi_2)
{
printf("请猜一个数:");
scanf("%d",&shu_zi_2);
if(shu_zi_2>shu_zi_1)
{
printf("猜大了\n");
}
else if(shu_zi_2<shu_zi_1)
{
printf("猜小了\n");
}
else{
printf("猜对了\n");
}
}
return 0;
}
#include<stdio.h>
int main()
{
int shu_zi_1=0,shu_zi_2=0;
printf("请输入一个数:");
scanf("%d",&shu_zi_1);
while(!(scanf("%d",&shu_zi_1)))//利用读入错误的情况下会返回0
{
scanf("%*[^\n]");
scanf("%*c");
printf("请再输入数据:");//确保读入一个正确格式的数据
}
scanf("%*[^\n]");//确保在正确读入的情况下再清理，比如输入6d时
scanf("%*c");
printf("请输入一个数:");
scanf("%d",&shu_zi_2);
printf("%d %d\n",shu_zi_1,shu_zi_2);
return 0;
}
#include<stdio.h>
int main()
{
int shu_zi=0,ci_shu[10]={0},xun_huan=0;
printf("请输入一个数:");
scanf("%d",&shu_zi);
/*while(shu_zi)
{
ci_shu[shu_zi%10]++;
shu_zi/=10;
}*/
do{//防止输入0时，不运行，所以用do... while
ci_shu[shu_zi%10]++;
shu_zi/=10;
}
while(shu_zi);
for(xun_huan=0;xun_huan<=9;xun_huan++)
{
if(ci_shu[xun_huan])
{
printf("数字%d出现了%d次\n",xun_huan,ci_shu[xun_huan]);
}
}
return 0;
}
#include <stdio.h>
int func1(int zheng_shu, int shu_zi);//返回次数
int func2(int zheng_shu);
int main()
{
int num = 0;
printf("请输入一个整数： ");
scanf("%d",&num);
func2(num);
return 0;
}
int func1(int zheng_shu, int shu_zi)//返回次数
{
int ci_shu = 0;
while(zheng_shu)
{
if(shu_zi==zheng_shu%10)
ci_shu ++;
zheng_shu=zheng_shu/10;
}
return ci_shu;
}
int func2(int zheng_shu)
{
int i = 0, j = 0;
int str[10] = {0};
int shu_zi = 0;
int a[10] = {0};
for(shu_zi = 0; shu_zi < 10; shu_zi ++){
str[shu_zi] = func1(zheng_shu, shu_zi); //str <= ci_shu
if(str[shu_zi]){
str[i] = str[shu_zi];
a[i] = shu_zi;
i ++;
}
}
/*
for(shu_zi = 0; shu_zi < 10; shu_zi ++)
{
str[i] = func1(zheng_shu, shu_zi);
if(str[i]){
a[i] = shu_zi;
i ++;
}
}
*/
for(j = 0; j < i ; j ++)
printf(" %d 出现 %d 次\n", a[j], str[j]);
printf("\n");
}
/*
//1.求一个整数中某个数字出现的个数
//2.输出该整数中含有的不同数字
#include <stdio.h>
int fun1(int zheng_shu,int shu_zi);//求一个整数中某个数字出现的个数
void fun2(int zheng_shu);//输出该整数中含有的不同数字
int main()
{
int n,num;
char str1[10]={0},str2[10]={0};
printf("请输入一个整数：");
scanf("%d",&num);
printf("请输入要统计的数字：");
scanf("%d",&n);
printf("%d 含有数字:\n",num);
fun2(num);
printf("\n");
printf("%d 有 %d 个 %d\n",num,fun1(num,n),n);
return 0;
}
int fun1(zheng_shu,shu_zi)
{
int i=0;
while(zheng_shu)
{
if(shu_zi==zheng_shu%10)
i++;
zheng_shu=zheng_shu/10;
}
return i;
}
void fun2(int zheng_shu)
{
int i=0,n=0;
int str[10]={0};
for(i=0;i<10;i++)
{
static int j=0;
while(i==zheng_shu%10){//用0~9数和输入的数每位上的数比较，
str[j]=i; //若相等就把这个数字保存到数组str中，
j++; //while就避免了数重复保存到str
i=0; //找到相同的数后，再判断更高位是否相同，在此要0开始比较
zheng_shu=zheng_shu/10;
}
continue;
}
for(n=0;n<j;n++)
printf("%d ",str[n]);
}
*/
#include<stdio.h>
int main()
{
int li_lv=0,nian=0,xun_huan=0,ge_shu=0;
float qian=100.0f;
printf("请输入利率和年数:");
scanf("%d%d",&li_lv,&nian);//打印表头
printf("年%7d%%\n",100+li_lv);
for(xun_huan=1;xun_huan<=nian;xun_huan++)
{
qian=(100+li_lv)/100.0f*qian;//用100.0f防止取整
printf("%d%9.2f\n",xun_huan,qian);
}
}
#include<stdio.h>
int main()
{
int li_lv=0,nian=0,xun_huan=0,xun_huan_1=0;
float qian[5]={100.0f,100.0f,100.0f,100.0f,100.0f};
printf("请输入最小利率和年数:");
scanf("%d%d",&li_lv,&nian);
printf("年");//先打印年
for(xun_huan=li_lv;xun_huan<=li_lv+4;xun_huan++)
{
printf("%8d%%",100+xun_huan);//打印表头
}
printf("\n");
for(xun_huan=1;xun_huan<=nian;xun_huan++)
{
printf("%2d",xun_huan);
for(xun_huan_1=li_lv;xun_huan_1<=li_lv+4;xun_huan_1++)
{
qian[xun_huan_1-li_lv]=(100+xun_huan)/100.0f*qian[xun_huan_1-li_lv];//用数组记录的上一个钱数来算
printf("%9.2f",qian[xun_huan_1-li_lv]);
}
printf("\n");//打印一行后换行
}
return 0;
}
#include<stdio.h>
int main()
{
int li_lv=0,nian=0,xun_huan=0,xun_huan_1=0,ge_shu=0;
printf("请输入利率个数:");
scanf("%d",&ge_shu);
float qian[ge_shu];
for(xun_huan_1=0;xun_huan_1<ge_shu;xun_huan_1++)
{
qian[xun_huan]=100.0f;//数组赋值
}
printf("请输入最小利率和年数:");
scanf("%d%d",&li_lv,&nian);
printf("年");//先打印年
for(xun_huan=li_lv;xun_huan<=(li_lv+ge_shu-1);xun_huan++)
{
printf("%8d%%",100+xun_huan);//打印表头不同利率
}
printf("\n");
for(xun_huan=1;xun_huan<=nian;xun_huan++)
{
printf("%2d",xun_huan);
for(xun_huan_1=li_lv;xun_huan_1<=li_lv+ge_shu-1;xun_huan_1++)
{
qian[xun_huan_1-li_lv]=(100+xun_huan_1)/100.0f*qian[xun_huan_1-li_lv];//用数组记录的上一个钱数来算
printf("%9.2f",qian[xun_huan_1-li_lv]);
}
printf("\n");//打印一行后换行
}
return 0;
}
#include<stdio.h>
int main()
{
int shu_zi[4][4]={{1},{0,1},{0,0,1},{0,0,0,1}};
int xun_huan=0,xun_huan_1=0;
/*int shu_zi[4][4]={[3][3]=1,[2][2]=1,[1][1]=1,[0][0]=1};//指定初始化
int xun_huan=0,xun_huan_1=0;*/
for(xun_huan=0;xun_huan<=3;xun_huan++)//行循环
{
for(xun_huan_1=0;xun_huan_1<=3;xun_huan_1++)//列循环
{
printf("%d ",shu_zi[xun_huan][xun_huan_1]);
}
printf("\n");
}
return 0;
}
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main()
{
int ge_shu=0,lei[10][10]={0},hang=0,lie=0;
srand(time(0));//设置种子
while(ge_shu<10)//【判断雷的个数是否小于10来循环，不用for循环，因为雷的位置可能重叠
{
hang=rand()%10;
lie=rand()%10;
if(!lei[hang][lie])//没有雷，布雷
{
lei[hang][lie]=1;
ge_shu++;
}
}
for(hang=0;hang<=9;hang++)//显示雷的位置
{
for(lie=0;lie<=9;lie++)
{
printf("%c",lei[hang][lie]?‘o‘:‘ ‘);//用三目运算符判断有雷用o表示，每雷空格
}
printf("\n");
}
return 0;
}
#include<stdio.h>
int jia(int shu_zi_1,int shu_zi_2)
{
return shu_zi_1+shu_zi_2;
}
int main()
{
int shu_zi_1=0;//修改形参的值对实参没有影响
shu_zi_1=jia(2,3)+4;
printf("%d\n",shu_zi_1);
return 0;
}
#include<stdio.h>//题目显示一个一维变长数组
/*
void xian_shi(int shu_zi[]) {//数组作参数，从参数拿到的数组本身不是数组，是别的东西
printf("sizeof(shu_zi)是%d\n",sizeof(shu_zi));//参数中数组使用sizeof得到的结果不是数组所占空间的大小，跟数组大小没关系
*/
void xian_shi(int shu_zi[],int ge_shu) {//数组作参数，只能在变量中增加参数的个数，知道变量中数组的个数
int xun_huan=0;
for( xun_huan=0;xun_huan<=(ge_shu-1);xun_huan++)//循环遍历每个变量的下标
{
printf("%d",shu_zi[xun_huan]);
}
printf("\n");
}
int main()
{
int ge_shu=0;
printf("请输入变量的个数:");
scanf("%d",&ge_shu);
int shu_zi[5]={1,2,3,4,5};//没初始化，打印的是随机数
xian_shi(shu_zi,5);
return 0;
}
#include<stdio.h>
void xian_shi(int shu_zi[],int zu,int ge_shu) {//显示二维数组，任何二维数组作参数时只能当成一维数组使用，不需要int shu_zi[][]
int xun_huan=0,xun_huan_1=0;
for(xun_huan=0;xun_huan<=(zu-1);xun_huan++)
{
for( xun_huan_1=0;xun_huan_1<=(ge_shu-1);xun_huan_1++)
{
printf("%d",shu_zi[xun_huan*ge_shu+xun_huan_1]);//注意打印时下标折算
}
printf("\n");
}
}
int main()
{
int shu_zi[3][2]={1,2,3,4,5,6};
xian_shi(shu_zi,3,2);
return 0;
}
#include<stdio.h>//变长数组
int main()
{
int ge_shu=0,xun_huan=0;
printf("请输入个数:");
scanf("%d",&ge_shu);
int shu_zi[ge_shu];//这样写可以，但vc运行不了
for(xun_huan=0;xun_huan<ge_shu;xun_huan++)
{
printf("请输入数字:");
scanf("%d",&shu_zi[xun_huan]);
}
for(xun_huan=ge_shu-1;xun_huan>=0;xun_huan--)
{
printf("%d",shu_zi[xun_huan]);
}
return 0;
}
#include<stdio.h>
int main()
{
int shu_zi=0,xun_huan=0,jie_guo=1;//jie_guo不能赋值0
printf("请输入一个数:");
scanf("%d",&shu_zi);
for(xun_huan=1;xun_huan<=shu_zi;xun_huan++)
{
jie_guo*=xun_huan;
}
printf("结果是%d\n",jie_guo);
return 0;
}
#include<stdio.h>
int jie_cheng(int shu_zi) {
int jie_guo=1;
if(1==shu_zi)//不要忘了
{
return 1;
}
else
{
return (jie_guo=shu_zi*jie_cheng(shu_zi-1));//递归阶乘
}
}
int main()
{
int shu_zi=0,jie_guo=1;
printf("请输入数字:");
scanf("%d",&shu_zi);
printf("%d! = %d\n",shu_zi,jie_cheng(shu_zi));
}
#include<stdio.h>
int yue(int xiao,int da) {
if(!(da%xiao))
{
return xiao;
}
else {
return yue(da%xiao,xiao);
}
}
int main()
{
int xiao=0,da=0;
printf("请分别输入小数和大数:");
scanf("%d%d",&xiao,&da);
yue(xiao,da);
printf("最大公约数是%d\n",yue(xiao,da));//注意写法yue(xiao,da),而不是da%xiao
return 0;
}
#include<stdio.h>
void han(int ge_shu,char yuan,char zhong,char mu_di) {
if(1==ge_shu)
{
printf("%d:%c-->%c\n",ge_shu,yuan,mu_di);
}
else
{
han(ge_shu-1,yuan,mu_di,zhong);//把上面ge_shu-1个盘子移动到中转柱上
printf("%d:%c-->%c\n",ge_shu,yuan,mu_di);//把最后一个盘子从初始位置移动到目的柱上
han(ge_shu-1,zhong,yuan,mu_di);//把中转柱上的ge_shu-1个盘子移到目的柱上
}
}
int main()
{
int ge_shu=0;
printf("请输入盘子的个数:");
scanf("%d",&ge_shu);
han(ge_shu,‘A‘,‘B‘,‘C‘);
return 0;
}
#include<stdio.h>
int main()
{
int shu_zi=0, xun_huan=0,shu_zi_1=1,shu_zi_2=1;//数字shu_zi_1,shu_zi_2分别记录编号0和1，注意赋值为1
printf("请输入数字编号:");
scanf("%d",&shu_zi);
if(shu_zi<=1)
{
printf("结果是1\n");
}
else
{
for(xun_huan=3;xun_huan<=shu_zi;xun_huan++)
{
int shu=shu_zi_1+shu_zi_2;
shu_zi_1=shu_zi_2;//注意将结果送给下一个数，以进行下一次循环
shu_zi_2=shu;
}
printf("结果是%d\n",shu_zi_2);
}
}
//数列 1 1 2 3 5 8 13
#include<stdio.h>
int f(int shu_zi) {
if(shu_zi<=1)
{
return 1;
}
else
{
return f(shu_zi-2)+f(shu_zi-1);//编号减-1，和-2
}
}
int main()
{
int shu_zi=0;
printf("请输入数字编号:");
scanf("%d",&shu_zi);
printf("结果是%d\n",f(shu_zi));
return 0;
}
c.数列用数组记录变量（加快递归速度）
#include<stdio.h>
int shu[100]={1,1};///放在外面作全局变量，速度要快很多
int f(int shu_zi)
{
if(!shu[shu_zi])//不是编号0和编号1的时候
{
shu[shu_zi]=f(shu_zi-2)+f(shu_zi-1);//不要写成f(shu[shu_zi-2])
return shu[shu_zi];//用数组作返回值加快运行速度
}
else
{
return shu[shu_zi];
}
}
int main()
{
int shu_zi=0;
printf("请输入数字编号:");
scanf("%d",&shu_zi);
printf("结果是%d\n",f(shu_zi));
return 0;
}
#include <stdio.h>
int shu_zi[10];
int ge_shu;
int f(){
int shu_zi=3;
printf("%d\n",shu_zi);
}
int f1(){
int shu_zi=5;
printf("%d\n",shu_zi);
}
int kong()
{
if(!ge_shu)
{
return 1;
}
else
{
return 0;
}
}
int man()
{
if(10==ge_shu)
{
return 1;
}
else
{
return 0;
}
}
void push(int shu)
{
shu_zi[ge_shu]=shu;
ge_shu++;
}
int pop()
{
ge_shu--;
return shu_zi[ge_shu];
}
int main()
{
kong();
man();
push(6);
pop();
f();
f1();
printf("%d ",shu_zi[6]);
return 0;
}
#include <stdio.h>
void jia_huan(int a,int b)
{
int t;
t=a;
a=b;
b=t;
}
int main()
{
int a=3,b=7;
jia_huan(a,b);
printf("%d,%d",a,b);
return 0;
}//3,7
/*
void jia_huan(int shu_zu[])
{
int t;
t=shu_zu[0];
shu_zu[0]=shu_zu[1];
shu_zu[1]=t;
}
int main()
{
int shu_zi[2]={3,7};
jia_huan(shu_zi);
printf("%d,%d",shu_zi[0],shu_zi[1]);
return 0;
}//7,3
*/
/*
void jia_huan(int *a,int *b)
{
int t;
t=*a;
*a=*b;
*b=t;
}
int main()
{
int a=3,b=7;
jia_huan(&a,&b);
printf("%d,%d",a,b);
return 0;
}//7,3
*/
#include <stdio.h>
int *zui_da(int *p_shu_zi_1,int *p_shu_zi_2)
{
return *p_shu_zi_1>*p_shu_zi_2 ? p_shu_zi_1 : p_shu_zi_2;
}
int main()
{
int shu_zi_1=0,shu_zi_2=0;
int *p_shu=NULL;
printf("请输入两个整数 ：");
scanf("%d %d",&shu_zi_1,&shu_zi_2);
p_shu=zui_da(&shu_zi_1,&shu_zi_2);
printf("最大数字是 %d\n",*p_shu);
return 0;
}
#include<stdio.h>
int main()
{
int shu[5]={1,2,3,4,5},xun_huan=0;
int *p_shu_zi=shu;//注意可以这样写
for(xun_huan=0;xun_huan<=4;xun_huan++)
// for(xun_huan=0;xun_huan<=4;p_shu_zi++)不可以这样写
{
printf("%d",shu[xun_huan]);//和下面几个结果一样
printf("%d",*(shu+xun_huan));
printf("%d",p_shu_zi[xun_huan]);
printf("%d\n",*(p_shu_zi+xun_huan));
}
for(xun_huan=0;xun_huan<=4;xun_huan++,p_shu_zi++)//可以这样实现指针变量的自增
{
printf("%d",*p_shu_zi);
}
printf("\n");
return 0;
}
#include <stdio.h>
int main()
{
char zi_fu_chuan[10];
printf("请输入字符串：");
fgets(zi_fu_chuan,10,stdin);
//scanf("%s",zi_fu_chuan);
printf("%s\n",zi_fu_chuan);
return 0;
}
#include <stdio.h>
#include <string.h>
int main(0
{
char zi_fu_chuan[]="abc";
char zi_fu_chuan_1[]="xyz";
printf("长度是 %d\n",strlen(zi_fu_chuan));
printf("合并结果是 %d\n",strcat(zi_fu_chuan,zi_fu_chuan_1);
)}
#include<stdio.h>
void f() {
static int shu_zi=3;//加static相当于全局变量定义，生命周期整个程序运行周期，作用域不变，第二次调用时不执行，直接跳过
printf("shu_zi是%d\n",shu_zi);
shu_zi++;
}
int main()
{
f();
f();
f();
return 0;
}
#include<stdio.h>
int *f()
{
int shu_zi=3;
return &shu_zi;//局部变量的地址不能作为返回值，因为函数结束时局部变量不存在，有警告
}
int *f1()
{
int shu_zi=5;
int shu_zi_1=7;
int shu_zi_2=shu_zi+shu_zi_1;
return NULL;
}
int main()
{
int *p_shu_zi=NULL;
p_shu_zi=f();
printf("%d\n",*p_shu_zi);//其实输出3是巧合，局部变量已释放，能输出3是没有其他操作。
f1();//这时3和5所在位置是同一位置
printf("%d\n",*p_shu_zi);
return 0;
}
//结论：绝对不能将局部变量作为返回值使用
#include<stdio.h>
#include<time.h>
int main()
{
int shi_jian=0,shi=0,fen=0,miao=0;
while(1)//实现死循环
{
shi_jian=time(0);
miao=shi_jian%60;
fen=shi_jian%3600/60;//从这一小时经过的秒数
shi=shi_jian%(24*3600)/3600;//从这一天开始经过的秒数
shi=(shi+8)%24;//调整时区
printf("%02d:%02d:%02d\r",shi,fen,miao);//\r是在原位置覆盖输出，Linux下结合在printf后加fflush(stdout);使用
//while(shi_jian==time(0));//控制当前这秒还没完的话不进行下一次循环
sleep(1);//这个函数是Linux平台的要结合unistd.h使用
}
return 0;
}
#include<stdio.h>
void jiao_huan(int *p_shu_zi_1,int *p_shu_zi_2)
{
//int *p_shu_zi_1,*p_shu_zi_2;
int shu=*p_shu_zi_1;
*p_shu_zi_1=(*p_shu_zi_2);
*p_shu_zi_2=shu;
}
int main()
{
int shu_zi_1=7,shu_zi_2=3;
jiao_huan(&shu_zi_1,&shu_zi_2);
printf("%d %d\n",shu_zi_1,shu_zi_2);
return 0;
}
#include<stdio.h>
int zui_da(int *p_shu_zi_1,int *p_shu_zi_2) {//返回的不是数，是最大的变量，要找到变量的地址，通过指针保存变量的地址数据
return *p_shu_zi_1>*p_shu_zi_2?p_shu_zi_1:p_shu_zi_2;//返回的是地址
}
int main()
{
int shu_zi_1=0,shu_zi_2=0;
int *p_shu;
printf("请输入两个数:");
scanf("%d%d",&shu_zi_1,&shu_zi_2);
p_shu=zui_da(&shu_zi_1,&shu_zi_2);
printf("最大的数是%d\n",*p_shu);
return 0;
}
#include<stdio.h>
void jiao_huan(int shu_zi,int shu_zi_1) {
int shu=shu_zi;
shu_zi=shu_zi_1;
shu_zi_1=shu;
printf("shu_zi是%d,shu_zi_1是%d\n",shu_zi,shu_zi_1);//写在这里也可以实现交换，也可用下面的数组实现交换
}
/*
void jiao_huan(int shu_zi[2]) {//注意前面加int
int shu=shu_zi[0];//注意前面加int
shu_zi[0]=shu_zi[1];
shu_zi[1]=shu;
}
*/
int main()
{ int shu_zi=3,shu_zi_1=7;
// int shu_zi[2]={3,5};
jiao_huan(3,7);
printf("shu_zi是%d,shu_zi_1是%d\n",shu_zi,shu_zi_1);//若写在这里不实现交换
// jiao_huan(shu_zi);//注意调用函数时的写法
// printf("shu_zi[0]是%d,shu_zi[1]是%d\n",shu_zi[0],shu_zi[1]);
// printf("shu_zi是%d,shu_zi_1是%d\n",shu_zi,shu_zi_1);
return 0;
}
#include<stdio.h>
int *f()
{
int shu_zi=3;
return &shu_zi;//局部变量的地址不能作为返回值，因为函数结束时局部变量不存在，有警告
}
int main()
{
int *p_shu_zi=NULL;
p_shu_zi=f();
printf("%d\n",*p_shu_zi);
return 0;
}
#include<stdio.h>
int main()
{
int shu[5]={1,2,3,4,5},xun_huan=0;
int *p_shu_zi=shu;//注意可以这样写
for(xun_huan=0;xun_huan<=4;xun_huan++)
// for(xun_huan=0;xun_huan<=4;p_shu_zi++)不可以这样写
{
printf("%d",shu[xun_huan]);//和下面几个结果一样
printf("%d",*(shu+xun_huan));
printf("%d",p_shu_zi[xun_huan]);
printf("%d\n",*(p_shu_zi+xun_huan));
}
for(xun_huan=0;xun_huan<=4;xun_huan++,p_shu_zi++)//可以这样实现指针变量的自增
{
printf("%d",*p_shu_zi);
}
return 0;
}
#include<stdio.h>
char *str_cpy(char *p_zi_fu_chuan_1,char *p_zi_fu_chuan_2)
{
if(!p_zi_fu_chuan_1||!p_zi_fu_chuan_2)
{
return p_zi_fu_chuan_1;
}
while(*p_zi_fu_chuan_2)
{
*p_zi_fu_chuan_1=*p_zi_fu_chuan_2;
p_zi_fu_chuan_1++;
p_zi_fu_chuan_2++;
}
//*p_zi_fu_chuan_1=‘\0‘;
char *p=p_zi_fu_chuan_1;
// return p;
}
int main()
{
char zi_fu_chuan_1[10]="abc";
//str_cpy(zi_fu_chuan _1,"xy");
printf("%s\n",str_cpy(zi_fu_chuan_1,"xy"));
return 0;
}
#include<stdio.h>
int main()
{
char *p_zi_fu_chuan="abc";//相当于p_zi_fu_chuan[]="abc";//char zi_fu_chuan=”abc”;没有‘\0’字符的数组不能当字符串使用
printf("%s\n","abc");
printf("%s\n",p_zi_fu_chuan);//指针就是字符变量的首地址
return 0;
}
#include<stdio.h>
#include<string.h>
int main()
{
char yong_hu[10]="admin\n";//注意要加/n
char mi_ma[10]="123456\n";
char ming[10],ma[10];
int xun_huan=0;
for(xun_huan=0;xun_huan<3;xun_huan++)//控制用户名输入3次
{
printf("请输入用户名:");
fgets(ming,10,stdin);
if(strcmp(ming,yong_hu))
{
printf("用户名输入错误\n");
continue ;
}
break;
}
for(xun_huan=0;xun_huan<3;xun_huan++)//控制密码输入3次
{
printf("请输入用户密码:");
fgets(ma,10,stdin);
if(strcmp(ma,mi_ma))
{
printf("密码输入错误\n");
continue ;
}
break;
}
if(xun_huan<3)
{
printf("登陆成功\n");
}
else
{
printf("登陆失败\n");
}
return 0;
}
#include <stdio.h>
int main(int argc,char *argv[])
{
int xun_huan = 0;
for(xun_huan = 0;xun_huan < argc;xun_huan ++)
{
printf("%s\n",argv[xun_huan]);
}
return 0;
}
#include<stdio.h>
#define zhaobenshan//没参，只是叫这个名字的宏，这个名字可以用
int main()
{
int cai =0;
printf("请点菜:");
scanf("%d",&cai);
#ifdef zhaobenshan//叫名字的宏被定义过
//#if defined(zhaobenshan)//效果与上面相同，运用广，可以与或非，加()构成逻辑表达式，定义过为真，没定义过为假
if(1==cai)
{
printf("这个菜没有\n");
}
else {
printf("这个菜有\n");
}
# else//普通人点菜,可以将前面定义的宏注释掉
{
printf("这个菜有\n");
}
# endif
return 0;
}
#include <stdio.h>
int main()
{
#if defined(JINGPING)
printf("120%%\n");
#elif !defined(GONGCHANG)
printf("100%%\n"); //#elif defined将代码分成更多组
#else
printf("80%%\n");
#endif
return 0;
}
#include<stdio.h>//宏的运算符练习
#define STR(n) #n //#运算符智能用在带参数的宏里，
//这个参数转换成字符串字面值
int main()
{
printf("结果是%s\n",STR(5-4));
return 0;
}//结果 ：5-4
#include<stdio.h>
//运算符可以把参数所代表的标识符和其他内容合并成为
//一个新的标识符，目的是有别于其他的标识符
#define global(n) g_##n //
int global(shu_zi);//定义全局变量
int main()
{
int global(shu_zi)=3;
printf("%d\n",global(shu_zi));
return 0;
}
/*#include<stdio.h>
#define local(n) l_##n //
//int local(shu_zi);
int main()
{
int local(shu_zi)=3;//定义局部变量
printf("%d\n",local(shu_zi));
return 0;
}
*/
gcc -E wenjian.c如下：
int main()
{
int l_shu_zi=3;// l_shu_zi=3取代了local(shu_zi)=3
printf("%d\n",l_shu_zi);
return 0;
}
#include <stdio.h>
int main()
{
printf("行号是%d\n",__LINE__);//输出此输出语句所在行
printf("文件是%s\n",__FILE__);//输出当前文件名
printf("日期是%s\n",__DATE__);//输出当前日期
printf("时间是%s\n",__TIME__);//输出当前时间
printf("%sC标准\n",__STDC__ ? "支持" : "不支持");//判断支不支持C标准
return 0;
}
#include<stdio.h>
#define pi 3.14f
#define zhou_chang(r) 2*pi*r
#define mian_ji(r) pi*r*r
int main()
{
float ban_jing=0;
printf("请输入半径:");
scanf("%d",&ban_jing);
printf("%g\n",zhou_chang(ban_jing));
printf("%g\n",mian_ji(ban_jing));
return 0;
}
#include<stdio.h>
#define SHE_ZHI(shu_zi) shu_zi=5//注意不要只写5，写成shu_zi=5
int han(int shu_zi) {
shu_zi=3;
}
int main()
{
int shu_zi=4;
han(shu_zi);
printf("%d\n",shu_zi);
SHE_ZHI(shu_zi);//会修改变量shu_zi的数值，因为宏是直接被文
//字替换的，因此参数就是宏内部使用的变量
printf("%d\n",shu_zi);
return 0;
}//答案： 4 5
#include<stdio.h>
#define cheng_ji(x,y) ((x)*(y))//注意保证宏的完整性,不然结果不对
int main()
{
printf("%d\n",cheng_ji(2+3,5-3));
printf("%d\n",20/cheng_ji(3+2,5-3));
return 0;
}
#include<stdio.h>
#define ping_fang(x) x*x
int main()
{
int shu_zi=7;
printf("%d\n",ping_fang(7));
printf("%d\n",ping_fang(++shu_zi));//不要使用自增自减的结果作为宏的参数，原因是宏不是函数，直接进行两次自增
return 0;
}
#include<stdio.h>
#define HANG 10
#define LIE 10
#define ge_shu(shu_zu) sizeof(shu_zu)/sizeof(shu_zu[0][0])
int main()
{
int LEI[HANG][LIE];
float shu_zu[3][4];
printf("变量个数是%d\n",ge_shu(LEI));//结果100
printf("变量个数是%d\n",ge_shu(shu_zu));
return 0;
}
#include<stdio.h>
int main()
{
int shu[5]={1,2,3,4,5},xun_huan=0;
int *p_shu_zi=shu;//注意可以这样写
for(xun_huan=0;xun_huan<=4;xun_huan++)
// for(xun_huan=0;xun_huan<=4;p_shu_zi++)不可以这样写
{
printf("%d",shu[xun_huan]);//和下面几个结果一样
printf("%d",*(shu+xun_huan));
printf("%d",p_shu_zi[xun_huan]);
printf("%d\n",*(p_shu_zi+xun_huan));
}
for(xun_huan=0;xun_huan<=4;xun_huan++,p_shu_zi++)//可以这样实现指针变量的自增
{
printf("%d",*p_shu_zi);
}
return 0;
}
十．秒转天
#include<stdio.h>
//每个宏都应该被包含在一对小括号中
//这样可以强制把宏当成一个整体
//宏的每个参数都应该用小括号包围
//这样可以保证每个参数先计算出结果
//然后在进行宏计算
#define zhuan_huan(s) (s)/(24 * 3600)
int main()
{
printf("天数是%d",zhuan_huan(48*3600));
return 0;
}
#include<stdio.h>
#define zhuan_huan(c) c<=‘z‘&&c>=‘a‘?c-‘a‘+‘A‘:c//当成数
#define zhuan_huan1(c) c=(c<=‘z‘&&c>=‘a‘?c-‘a‘+‘A‘:c)//当成复杂的处理过程。注意这种写法//时加c=
int main()
{
char zi_fu=0;
printf("请输入字符:");
scanf("%c",&zi_fu);
printf("%c\n",zhuan_huan(zi_fu));
zhuan_huan1(zi_fu);//两种写法
printf("%c\n",zi_fu);
return 0;
}
（scanf输入格式要和语句中一样，为避免键盘输入误输，而导致重新按格式输入，以下就是解决办法）
#include<stdio.h>
int readint() {
int shu_zi=0;
while(!scanf("%d",&shu_zi))//读错的话，返回是0
{
scanf("%*[^\n]");//清理缓冲区
scanf("%*c");
printf("请再输入一个数:");
}
scanf("%*[^\n]");//再次清理缓冲区
scanf("%*c");
return shu_zi;//注意是return shu_zi,而不是readint
}
int main()
{
int shu_zi=0;
printf("请输入一个数:");
//scanf("%d",&shu_zi);
shu_zi=readint();//使用这个函数读取整数，不使用scanf
printf("数是%d\n",shu_zi);
return 0;
}
#ifndef __READINT_H__
#define __READINT_H__
void readInt();
int jie_guo;
#endif//_READINT_H__
/*头文件声明*/
#include<stdio.h>
#include"readInt.h"
extern int jie_guo//声明全局变量，读到的数放在全局变量
void readInt() {
int shu_zi=0;
while(!scanf("%d",&shu_zi))//读错的话，返回是0
{
scanf("%*[^\n]");//清理缓冲区
scanf("%*c");
printf("请再输入一个数:");
}
scanf("%*[^\n]");//再次清理缓冲区
scanf("%*c");
return jie_guo;//注意是return jie_guo
}
#include<stdio.h>
#include"readInt.h"
int main()
{
int shu_zi=0;
printf("请输入一个数:");
//scanf("%d",&shu_zi);
jie_guo=readint();//使用这个函数读取整数，不使用scanf
printf("数是%d\n",jie_guo);
return 0;
}
简化多文件程序编译过程
#include<stdio.h>
int main()
{
struct ren {//结构体声明
float shen_gao;//没有声明变量，只是描述了变量shen_gao和结构体之间的关系
int nian_ling;
char xing_bie;
} ren1;
struct ren ren2={1.78,23,‘f‘};//结果体变量声明及初始化
printf("身高是%g 年龄是%d 性别是%c\n",ren2.shen_gao,ren2.nian_ling,ren2.xing_bie);//通过结构体变量的名称获得其中各个简单变量
return 0;
}
#include<stdio.h>
typedef struct ren {
float shen_gao;
int nian_ling;
char xing_bie;
} ren;
ren *du(ren *p_ren) {//结构体变量的指针作为函数的参数和返回值，可以提高程序运行效率
// ren ren1={0.0f,0,0};
printf("请输入身高、年龄、性别:");
scanf("%f%d%c",&(p_ren->shen_gao),&(p_ren->nian_ling),&(p_ren->xing_bie));//注意此//时的写法 通过结构体变量地址表示其中简单变量的语法要使用 ->
return p_ren;//返回结构体变量的地址
}
int main()
{ ren ren1={0.0f,0,0};//养成初始化的习惯
ren* p_ren= NULL;
p_ren=du(&ren1);
printf("身高是%g,年龄是%d,是%c\n",p_ren->shen_gao,p_ren->nian_ling,p_ren->xing_bie);
return 0 ;
}//结果性别显示不出来
#include<stdio.h>
typedef struct ren {
float shen_gao;
int nian_ling;
char xing_bie;
} ren;
ren du() {//ren的结构体变量做返回值
ren ren1={0.0f,0,0};
printf("请输入身高、年龄、性别:");
scanf("%f%d%c",&ren1.shen_gao,&ren1.nian_ling,&ren1.xing_bie);
return ren1;//使用读函数读，不在主函数读，这样可以，但不好，在调用的时候参数和返回值都会复制，因为ren1在栈里，不同的栈里
}
int main()
{ ren ren1={0.0f,0,0};//养成初始化的习惯
ren1= du();
printf("身高是%g,年龄是%d,性别是%c\n",ren1.shen_gao,ren1.nian_ling,ren1.xing_bie);
return 0 ;
}
#include <stdio.h>
typedef struct{//结果：大小是8个字节
char zi_fu;
char zi_fu_1;
int shu_zi;
}jie_gou;
typedef struct{//结果：大小是8个字节
int shu_zi;
char zi_fu;
char zi_fu_1;
}jie_gou;
typedef struct{//结果：大小是12个字节 这个结果变大是因为不同类型变量产生间隙，字节变大，因而相同类型变量相邻可减小字节
char zi_fu;
int shu_zi;
char zi_fu_1;
}jie_gou;
int main()
{
printf("sizeof(jie_gou)是 %d\n",sizeof(jie_gou));
return 0;
}
#include<stdio.h>
typedef struct {
char lei:1;//后面用冒号表示有几个二进制位,位域不适合浮点型数据
char ge_shu:4;
char zhuang_tai:2; //结果：1 7位，没满8位按8位算，即1字节
}wei_zhi;
typedef struct {//没有用使用域
char lei;
char ge_shu;
char zhuang_tai;
}wei_zhi_1;
int main()
{
wei_zhi wei;
printf("sizeof(wei_zhi)是%d\n,sizeof(wei_zhi_1)是%d\n",sizeof(wei_zhi),sizeof(wei_zhi_1));
// printf("%p",&(wei.ge_shu));//位域在字节里面，没有地址，字节才有地址
return 0;
}
#include <stdio.h>
union lian_he{//是指两个不同字节的不同使用方式，你可以把它当
//成字符来用，也可以当成整数来用，占的是同一地址
int shu_zi;
char zi_fu[2];
}lian_he_1;
int main()
{
printf("sizeof(lian_he_1)是 %d\n",sizeof(lian_he_1));
printf("%p\n%p\n",&lian_he_1.shu_zi,&lian_he_1.zi_fu[0]);
lian_he_1.shu_zi = 0x12345678;
printf("0x%x\n",lian_he_1.zi_fu[0]);//大端，小端，本系统采用小端
return 0;
}
#include <stdio.h>
int main()
{
enum ji_jie{SPR,SUM,AUT=6,WIN};
//printf("SPR是 %d\n",SPR);
//printf("WIN是 %d\n",WIN);
enum ji_jie season;
season=SUM;
printf("season是 %d\n",season);
return 0;
}
//对枚举型的变量赋整数值时，需要进行类型转换。
#include <stdio.h>
enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN };
void main()
{
enum DAY yesterday, today, tomorrow;
yesterday = TUE;
today = (enum DAY) (yesterday + 1); //类型转换
tomorrow = (enum DAY) 30; //类型转换
//tomorrow = 3; //错误
printf("%d %d %d \n", yesterday, today, tomorrow); //输出：2 3 30
}
#include<stdio.h>
enum type {CHAR,INT,FLOAT};
void xian_shi(int lei_xing,void*p_shu)//void仅说明指针变量，没说什么类型
{
switch(lei_xing) {
case CHAR:
printf("%c\n",*((char*)p_shu));//void *数据使用前要强制转换字符类型指针，不能通过地址去拿
break;
case INT:
printf("%d\n",*((int*)p_shu));
break;
case FLOAT:
printf("%f\n",*((float*)p_shu));
break;
}
}
int main()
{
char zi_fu=‘a‘;
int shu=3;
float shu_zi=3.5f;
printf("%c\n",‘a‘);//验证跟下一行显示结果是不是一样
xian_shi(CHAR,&zi_fu);
printf("%d\n",3);
xian_shi(INT,&shu);
printf("%f\n",3.5f);
xian_shi(FLOAT,&shu_zi);
return 0;
}
/*#include<stdio.h>
int main()
{
int shu[3]={0},xun_huan=0;//分配在栈里
for(xun_huan=0;xun_huan<3;xun_huan++)
{
printf("请输入一个数:");
scanf("%d",shu+xun_huan);//可以这样读入一个数
}
for(xun_huan=2;xun_huan>=0;xun_huan--)
{
printf("%d",shu[xun_huan]);
}
return 0;
}
*/
#include<stdio.h>
#include<stdlib.h>
int main()
{
int *p_shu_zi=NULL,xun_huan=0;
p_shu_zi=(int*)malloc(3*sizeof(int));//malloc(3*sizeof(int))从堆中分配3个字节，得到首字节地址，但是是任意的void*类型，后强制转换p_shu_zi可以当成数组（栈里）用，但在堆里
if(!p_shu_zi)//分配失败返回NULL
{
printf("内存分配失败\n");
return 0;
}
for(xun_huan=0;xun_huan<3;xun_huan++)
{
printf("请输入一个数:");
scanf("%d",p_shu_zi+xun_huan);//可以这样读入一个数
}
for(xun_huan=2;xun_huan>=0;xun_huan--)
{
printf("%d\n",p_shu_zi[xun_huan]);//或者*(p_shu_zi+xun_huan)
}
free(p_shu_zi);//释放从堆中分配的所有变量
p_shu_zi=NULL;//释放掉从堆中变量后，p_shu_zi就成为了野指针，
//必须把指针变量设置为NULL,释放完空间后要把指针变量设置成NULL
return 0;
}
#include<stdio.h>
#include<stdlib.h>
int main()
{
int *p_shu_zi=NULL, *p_shu_zi_1=NULL,xun_huan=0;
// p_shu_zi=(int*)malloc(3*sizeof(int));不保证所有变量都被清0
p_shu_zi=(int*)calloc(3,sizeof(int ));//保证所有变量都被清0了
if(p_shu_zi)//内存分配成功
{
printf("%p\n",p_shu_zi);
for(xun_huan=0;xun_huan<3;xun_huan++)
{
printf("%d\n",*(p_shu_zi+xun_huan));
*(p_shu_zi+xun_huan)=xun_huan+1;
}
int *p_shu_zi_1=realloc(p_shu_zi,6*sizeof(int));//把原来的三个整数空间调整六个整数空间，//realloc原有不变，但不清0
if(p_shu_zi_1) {//如果成功
printf("%p %p\n",p_shu_zi,p_shu_zi_1);//测试新旧两个地址
p_shu_zi=p_shu_zi_1;//用新地址覆盖掉旧地址
for(xun_huan=0;xun_huan<6;xun_huan++)//打印新空间变量的个数
{
printf("%d ",*(p_shu_zi+xun_huan));
}
printf("\n");
}
}
return 0;
}
/*
#include <stdio.h>
int bi_jiao_1(const void* p_shu_zi_1, const void* p_shu_zi_2)
{
return 0-bi_jiao(p_shu_zi_1,p_shu_zi_2);
}
int bi_jiao(const void* p_shu_zi_1, const void* p_shu_zi_2)
{
if(*(int *)p_shu_zi_1>*(int *)p_shu_zi_2)
{
return 1;
}
else if(*(int *)p_shu_zi_1<*(int *)p_shu_zi_2)
{
return -1;
}
else
{
return 0;
}
}
void pai_xu(int shu_zi[],int ge_shu,int (*p_func)(const void *,const void *))
{
if(1==p_func(&shu_zi[0],&shu_zi[1]))
{
int shu=shu_zi[0];
shu_zi[0]=shu_zi[1];
shu_zi[1]=shu;
}
}
int main()
{
int shu_zi[2]={7,2};
pai_xu(shu_zi,2,bi_jiao);
printf("%d %d\n",shu_zi[0],shu_zi[1]);
pai_xu(shu_zi,2,bi_jiao_1);
printf("%d %d\n",shu_zi[0],shu_zi[1]);
}
*/
#include <stdio.h>
#include <stdlib.h>
int bi_jiao_1(const void* p_shu_zi_1, const void* p_shu_zi_2)
{
return 0-bi_jiao(p_shu_zi_1,p_shu_zi_2);
}
int bi_jiao(const void* p_shu_zi_1, const void* p_shu_zi_2)
{
if(*(int *)p_shu_zi_1>*(int *)p_shu_zi_2)
{
return 1;
}
else if(*(int *)p_shu_zi_1<*(int *)p_shu_zi_2)
{
return -1;
}
else
{
return 0;
}
}
int main()
{
int shu_zi[2]={7,2};
qsort(shu_zi,2,sizeof(int),bi_jiao);
printf("%d %d\n",shu_zi[0],shu_zi[1]);
qsort(shu_zi,2,sizeof(int),bi_jiao_1);
printf("%d %d\n",shu_zi[0],shu_zi[1]);
}
/*#include<stdio.h>
int main()
{
int shu_zi=3;
const int *p_shu_zi=NULL;//不可以通过这个指针修改别的变量但是指针本身可以被修改
//int* const p_shu_zi_1=NULL;
p_shu_zi=&shu_zi;
//*p_shu_zi=5;//不可以通过指针去修改，const指针指向的变量不可以被修改
printf("请输入一个数:");
//scanf("%d",p_shu_zi);//编译出现警告
scanf("%d",&shu_zi);//shu_zi本身数值可以改的，但不能通过p_shu_zi指针修改
printf("%d %d\n",p_shu_zi,shu_zi);
return 0;
}
*/
#include<stdio.h>
int main()
{
int shu_zi=3;
int *const p_shu_zi=&shu_zi;//指针本身不可以被修改，但是可以通过它修改别的变量
//p_shu_zi=&shu_zi;
// *p_shu_zi=5;
printf("请输入一个数:");
scanf("%d",p_shu_zi);
//scanf("%d",&shu_zi);
printf("%d %d\n",*p_shu_zi,shu_zi);
return 0;
}
#include <stdio.h>
int main()
{
int shu_zi = 3;
int *p_shu_zi = &shu_zi;
int **pp_shu_zi = &p_shu_zi;
printf("%d %p %p\n",**pp_shu_zi,*pp_shu_zi,pp_shu_zi);
return 0;
}
#include<stdio.h>
#include<stdlib.h>
void chai_fen(char *zi_fu_chuan,char **pp_zi_fu) {//第一个参数表示要用来拆分的字符串，第二个参数表示字符指针地址，用来放拆分好得到新字符串地址
int xun_huan=0;
char *p_zi_fu=NULL;
while(*(zi_fu_chuan+xun_huan)!=‘:‘)
{
xun_huan++;
}
p_zi_fu=(char*)malloc(xun_huan+1);//自动分配空间
xun_huan=0;
while(*(zi_fu_chuan+xun_huan)!=‘:‘)
{
*(p_zi_fu+xun_huan)=*(zi_fu_chuan+xun_huan);//复制到新字符对应的位置
xun_huan++;
}
*(p_zi_fu+xun_huan)=‘\0‘;//用0也可以，遇到结束
*pp_zi_fu=p_zi_fu;//p_zi_fu是首地址
}
int main()
{
char zi_fu_chuan[]="1234:5678:9012";
char *p_zi_fu=NULL;
chai_fen(zi_fu_chuan,&p_zi_fu);//用字符指针变量地址
printf("拆分结果是%s\n",p_zi_fu);//p_zi_fu用来记录得到的字符串首地址
free(p_zi_fu);
p_zi_fu=NULL;
return 0;
}
#include <stdio.h>
int jia(int x,int y)
{
return x + y;
}
int main()
{
int (*p_func)(int,int);
p_func = jia;
printf("函数的地址是 %p和%p\n",jia,p_func);
return 0;
}
/*#include<stdio.h>
int bi_jiao(const void* p_shu_zi_1,const void*p_shu_zi_2)
{
if(*(int*)p_shu_zi_1>*(int*)p_shu_zi_2)
{
return 1;
}
else if(*(int*)p_shu_zi_1<*(int*)p_shu_zi_2)
{
return -1;
}
else
{
return 0;
}
}
int bi_jiao_1(const void* p_shu_zi_1,const void*p_shu_zi_2)
{
return 0-bi_jiao(p_shu_zi_1,p_shu_zi_2);
}
void pai_xu(int shu_zi[],int ge_shu)
{
if(1==bi_jiao(&shu_zi[0],&shu_zi[1]))
{
int shu=shu_zi[0];
shu_zi[0]=shu_zi[1];
shu_zi[1]=shu;
}
}
int main()
{
int shu_zi[2]={7,2};
pai_xu(shu_zi,2);
printf("%d %d",shu_zi[0],shu_zi[1]);
return 0;
}
*/
#include<stdio.h>
int bi_jiao(const void* p_shu_zi_1,const void*p_shu_zi_2)
{
if(*(int*)p_shu_zi_1>*(int*)p_shu_zi_2)
{
return 1;
}
else if(*(int*)p_shu_zi_1<*(int*)p_shu_zi_2)
{
return -1;
}
else
{
return 0;
}
}
int bi_jiao_1(const void* p_shu_zi_1,const void*p_shu_zi_2)
{
return 0-bi_jiao(p_shu_zi_1,p_shu_zi_2);
}
/*void pai_xu(int shu_zi[],int ge_shu,int (*p_func)(const void*, const void*))//改成函数指针
{
if(1==p_func(&shu_zi[0],&shu_zi[1]))//注意
{
int shu=shu_zi[0];
shu_zi[0]=shu_zi[1];
shu_zi[1]=shu;
}
}
*/
int main()
{
int shu_zi[2]={7,2};
//pai_xu(shu_zi,2,bi_jiao);//这样可以在main()里修改哪个排序
qsort(shu_zi,2,sizeof(int),bi_jiao);//用qsort函数进行排序
printf("%d %d",shu_zi[0],shu_zi[1]);
return 0;
}
#include<stdio.h>
#include<stdlib.h>
//qsort函数bi_jiao函数必须以这种形式写int bi_jiao(const void * p_shu_zi_1,const void * p_shu_zi_2)
int bi_jiao(const void*p_shu_zi_1,const void*p_shu_zi_2)
{
//指针变量的地址，用二级指针来描述，为拿到整数变量的地址，加**
int shu_zi_1=**((int**)p_shu_zi_1),shu_zi_2=**((int**)p_shu_zi_2);
if(shu_zi_1>shu_zi_2)
{
return 1;
}
else if(shu_zi_1<shu_zi_2)
{
return -1;
}
else
{
return 0;
}
}
int main(int argc,int*argv[])
{
int shu_zi[5]={1,2,4,-3,6},xun_huan=0;
int *p_shu_zi[]={shu_zi,shu_zi+1,shu_zi+2,shu_zi+3,shu_zi+4};
qsort(p_shu_zi,5,sizeof(int*),bi_jiao);
for(xun_huan=0;xun_huan<=4;xun_huan++)
{
printf("%d ",*p_shu_zi[xun_huan]);
}
return 0;
}
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int bi_jiao(const void *p_str,const void *p_str_1)
{
return strcmp(*(char**)p_str,*(char**)p_str_1);
}
int main()
{
char *str[]={"China","Russia","American","Frence","England"};
int xun_huan=0;
qsort(str,5,sizeof(char*),bi_jiao);
for(xun_huan=0;xun_huan<=4;xun_huan++)
{
printf("结果是%s\n",str[xun_huan]);
}
return 0;
}
#include <stdio.h>
#include <stdlib.h>
//qsort函数bi_jiao函数必须以这种形式写int bi_jiao(const void * p_shu_zi_1,const void * p_shu_zi_2)
int bi_jiao(const void * p_shu_zi_1,const void * p_shu_zi_2)
{
//指针变量的地址，用二级指针来描述，为拿到整数变量的地址，加**
int shu_zi_1=**(int**)p_shu_zi_1,shu_zi_2=**(int**)p_shu_zi_2;
if(shu_zi_1>shu_zi_2)
{
return 1;
}
else if(shu_zi_1<shu_zi_2)
{
return -1;
}
else
{
return 0;
}
}
int main(int argc,int*argv[])
{
int shu_zi[]={9,5,-7,-3,13},xun_huan=0;
int *p_shu_zi[]={shu_zi,shu_zi+1,shu_zi+2,shu_zi+3,shu_zi+4};
qsort(p_shu_zi,5,sizeof(int*),bi_jiao);
for(xun_huan=0;xun_huan<5;xun_huan++)
{
printf("%d ",*(p_shu_zi[xun_huan]));
}
printf("\n");
return 0;
}
#include <stdio.h>
int main()
{
int shu_zi[3]={1,2,3};
int shu_zi_1[2][3]={1,2,3,4,5,6};
int (*p_shu_zi)[3];// 声明数组指针，和int p_shu_zi[][]效果一样
//p_shu_zi=NULL;
p_shu_zi=&shu_zi;//数组指针用来记录数组的地址
printf("p_shu_zi是 %p,*p_shu_zi是 %p\n",p_shu_zi,*p_shu_zi);
//p_shu_zi是 0012FF34,*p_shu_zi是 0012FF34 一样的，这就是数组指针的特点
printf("shu_zi_1是 %p,*shu_zi_1是 %p\n",shu_zi_1,*shu_zi_1);
//shu_zi_1是 0012FF24,*shu_zi_1是 0012FF24 一样
p_shu_zi=shu_zi_1;
printf("p_shu_zi+1是 %p,*p_shu_zi+1是 %p\n",p_shu_zi+1,*p_shu_zi+1);
//数组指针相当二维数组，二维数组+1跨越一组变量，
//数组指针与二维数组的区别就在于数组指针可以被赋值，二维数组名称不可赋值
return 0;
}
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int bi_jiao(const void *p_str,const void *p_str_1)
{
return strcmp(*(char**)p_str,*(char**)p_str_1);
//转成二级指针，取一级指针比较两字符串
}
int main()
{
char *str[]={"China","Russia","American","Frence","England"};
int xun_huan=0;
qsort(str,5,sizeof(char*),bi_jiao);
for(xun_huan=0;xun_huan<=4;xun_huan++)
{
printf("结果是%s\n",str[xun_huan]);
}
return 0;
}
//rewind 将文件位置指针移到文件的开头
//fseek 将文件位置指针移到文件任意位置
//ftell 告诉当前文件位置在哪儿
/*#include <stdio.h>
int main()
{
FILE *p_file=NULL;
char zi_fu=0;
p_file=fopen("a.txt","r");
if(p_file)
{
zi_fu=fgetc(p_file);
printf("%c",zi_fu);
zi_fu=fgetc(p_file);
printf("%c",zi_fu);
zi_fu=fgetc(p_file);
printf("%c",zi_fu);
printf("\n");
rewind(p_file);
fclose(p_file);
p_file=NULL;
}
return 0;
}*/
#include <stdio.h>
int main()
{
FILE *p_file=NULL;
char zi_fu=0;
p_file=fopen("a.txt","r");//a.txt中Hello World!
if(p_file)
{
fseek(p_file,6,SEEK_SET);//把位置指针移动到从文件头开始向后6个字节处的位置
zi_fu=fgetc(p_file);
printf("%c",zi_fu);
fseek(p_file,-2,SEEK_END);//把位置指针移动到从文件尾开始向前2字节处的位置
zi_fu=fgetc(p_file);
printf("%c",zi_fu);
fseek(p_file,-3,SEEK_CUR);//把位置指针移动到从当前位置向前3字节的位置
zi_fu=fgetc(p_file);
printf("%c\n",zi_fu);
printf("当前位置指针的位置是 %d\n",ftell(p_file));
//ftell 告诉当前文件位置在哪儿
fclose(p_file);
p_file=NULL;
}
return 0;
}
fseek，rewind练习
#include<stdio.h>
int main()
{
FILE *p_file=NULL;
char zi_fu=0;
p_file=fopen("a.txt","r");
if(p_file)
{
fseek(p_file,-3,SEEK_END);//第一个参数文件指针，第二个偏移量，第三个，基准位置
zi_fu=fgetc(p_file);
printf("%c",zi_fu);
//rewind(p_file);//用rewind移动到文件开头
zi_fu=fgetc(p_file);
printf("%c",zi_fu);
zi_fu=fgetc(p_file);
printf("%c\n",zi_fu);
fclose(p_file);
p_file=NULL;
}
return 0;
}
#include<stdio.h>
int main()
{
FILE *p_file=NULL;
char zi_fu=0;
p_file=fopen("a.txt","r");
if(p_file)
{
while(zi_fu!=EOF)
{
zi_fu=fgetc(p_file);
//if(zi_fu!=EOF)
//{
printf("%c",zi_fu);
// }
}
}
fclose(p_file);
p_file=NULL;
return 0;
}
写文件
#include<stdio.h>
int main()
{
FILE *p_file=NULL;
char str[]="Hello World!";
int xun_huan=0;
p_file=fopen("a.txt","w");
if(p_file)
{
while(str[xun_huan]){
if(EOF == fputc(str[xun_huan],p_file)){
break;
}
xun_huan++;
}
fclose(p_file);
p_file=NULL;
}
return 0;
}
#include<stdio.h>
int main()
{
char zi_fu=0;
FILE *p_src=NULL, *p_dest=NULL;
p_src=fopen("a.txt","r");
if(p_src)
{
p_dest=fopen("b.txt","w");
if(p_dest)
{
while(zi_fu!=EOF)
{
zi_fu=fgetc(p_src);
if(zi_fu!=EOF)
{
fputc(zi_fu,p_dest);
}
}
fclose(p_dest);
p_dest=NULL;
}
fclose(p_src);
p_src=NULL;
}
return 0;
}
//fprintf和fscanf
/*#include <stdio.h>
int main()
{
FILE *p_file=NULL;
char zi_fu=0;
p_file=fopen("d.txt","w");
if(p_file)
{
fprintf(p_file,"%d %c %g\n",15,‘t‘,1.8f);
fclose(p_file);
p_file=NULL;
}
return 0;
}*/
#include <stdio.h>
int main()
{
FILE *p_file=NULL;
char zi_fu=0;
char a_char=0;
int value=0;
float a_float=0.0f;
p_file=fopen("d.txt","r");
if(p_file)
{
fscanf(p_file,"%d %c %g",&value,&a_char,&a_float);
printf("%d %c %g\n",value,a_char,a_float);
fclose(p_file);
p_file=NULL;
}
return 0;
}
//printf和scanf都是变长参数函数
/*#include <stdio.h>
#include <stdarg.h>
void func(int cnt,...)//通过确定的参数确定不确定的参数
{
int xun_huan=0;
va_list v;
va_start(v,cnt);//找到不确定的参数
for(xun_huan=0;xun_huan<cnt;xun_huan++)
{
printf("%d ",va_arg(v,int));//拿到所有int型的参数
}
printf("\n");
va_end(v);//清理
}
int main()
{
func(3,9,-6,17);
func(5,1,8,-15,-27,2);
return 0;
}
*/
//printf和scanf都是变长参数函数
#include <stdio.h>
#include <stdarg.h>
int max(int cnt,...)//通过确定的参数确定不确定的参数
{
int res=1<<31;//最小整数
int xun_huan=0;
va_list v;
va_start(v,cnt);//找到不确定的参数
for(xun_huan=0;xun_huan<cnt;xun_huan++)
{
int value=va_arg(v,int);//拿到所有int型的参数
if(value > res)
{
res = value;
}
}
va_end(v);//清理
return res;
}
int main()
{
printf("最大数是 %d\n",max(3,9,-6,17));
printf("最大数是 %d\n",max(5,1,8,-15,-27,2));
return 0;
}
/*#include <stdio.h>
int main()
{
FILE *p_file=NULL;
int values[3]={1,2,3},num=0;
p_file=fopen("a.bin","w+b");
if(p_file)
{
num=fwrite(values,sizeof(int),3,p_file);
printf("写入%d个整数\n",num);
fclose(p_file);
p_file=NULL;
}
return 0;
}
*/
#include <stdio.h>
int main()
{
FILE *p_file=NULL;
int values[3]={0},num=0;
p_file=fopen("a.bin","rb");
if(p_file)
{
num=fread(values,sizeof(int),3,p_file);
printf("读入%d个整数\n",num);
printf("%d %d %d\n",values[0],values[1],values[2]);
fclose(p_file);
p_file=NULL;
}
return 0;
}
//fputs和fgets
#include <stdio.h>
int main()
{
FILE *p_file=NULL;
char zi_fu=0;
p_file=fopen("c.txt","w");
if(p_file)
{
fputs("xyz abc",p_file);//失败返回EOF
fclose(p_file);
p_file=NULL;
}
return 0;
}
/*
#include <stdio.h>
int main()
{
FILE *p_file=NULL;
char zi_fu=0;
p_file=fopen("c.txt","r");
if(p_file)
{
fgets("xyz abc",p_file);//失败返回EOF
fclose(p_file);
p_file=NULL;
}
return 0;
}
*/
#include <stdio.h>
int main()
{
char a_char=‘t‘;
int value=27;
float a_float=3.8f;
char str[20];
sprintf(str,"%c %d %g\n",a_char,value,a_float);
//按格式将三个变量打印到str
printf("%s",str);
a_char=0;
value=0;
a_float=0.0f;
sscanf(str,"%c %d %g\n",&a_char,&value,&a_float);
printf("%c %d %g\n",a_char,value,a_float);
return 0;
}
#include <stdio.h>
int main()
{
int value=0;
float a_float=0.0f;
value=atoi("297");
printf("数字是 %d\n",value);
a_float=atof("4.7");
printf("数字是 %g\n",a_float);//结果：297, 4.7
return 0;
}
int shu_zi;//整数变量
int *p_shu_zi;//指针变量，记录整数变量的地址
int shu_zu[3];//数组变量
int (*p_shu_zu)[3];//数组指针，记录数组的地址
int shu_zu[2][3];//二维数组
int *p_shu_zi[3];//指针数组，就是数组，存的是指针变量
int **p_shu_zi;//二级指针，记录一级指针变量的地址
int f();//函数，函数名称本身代表了函数的开始地址
int (*p)();//函数指针，记录函数地址
int *p();//指针函数，就是函数，函数把地址数据当返回值使用
NULL//空指针,0地址
野指针//任何指针变量记着无效地址数据，又不是空地址 为避免野指针，声明指针变量时要初始化，知道有野指针，立刻清成空地址
void*//可记录任何地址数据，使用时首先要转换类型
FILE*//文件指针
标签：
原文地址：http://blog.csdn.net/quanshenyue/article/details/51405725
