1. 用c语言写的socket编程。传输的数据流是自定义tlv格式的，len有没有必要转换成网络字节序
转换了最好，免得以外；
如果你更换了环境之后，突然切换了big/little-endian，那么程序将会失败的；
明确的Interfce总是好的，即便出现了错误也是只有少数可能
2. 高分用C语言做个游程编码程序，下面我解释具体意思，高手来
#include<stdio.h>
#include<stdlib.h>
#include<memory.h>
#include<string.h>
#defineMAXLINE1024
#defineDIM","
typedefstructSTRLINK
{
intv;
intt;
structSTRLINK*next;
}LINK;
staticLINK*head=NULL;
staticintfreelink()
{
LINK*tmp=NULL;
if(head==NULL)return0;
while(head->next){
tmp=head->next;
free(head);
head=tmp;
}
free(head);
return0;
}
staticintinode(intv)
{
LINK*tmp,*newlink;
tmp=head;
newlink=(LINK*)malloc(sizeof(LINK));
if(newlink==NULL)return-1;
newlink->v=v;
newlink->t=1;
newlink->next=NULL;
if(tmp==NULL){
head=newlink;
return0;
}
while(tmp->next!=NULL){
if(tmp->v==v){
tmp->t++;
return0;
}
tmp=tmp->next;
}
if(tmp->v==v){
tmp->t++;
return0;
}else{
tmp->next=newlink;
return0;
}
}
staticintprt2file(FILE*fout,intlinenum)
{
LINK*tmp=head;
if(head==NULL)return0;
while(tmp->next){
fprintf(fout,"(%d,%d,%d),",tmp->v,tmp->t,linenum);
tmp=tmp->next;
}
fprintf(fout,"(%d,%d,%d) ",tmp->v,tmp->t,linenum);
return0;
}
intmain(intargc,char*argv[])
{
FILE*fin,*fout;
charline[MAXLINE+1],*str;
intlinenum,v;
if(argc!=3){
printf("USAGE:%s输入文件输出文件 ",argv[0]);
}
fin=fopen(argv[1],"r");
if(fin==NULL){
printf("inputfile[%s]cannotopen! ",argv[1]);
return-1;
}
fout=fopen(argv[2],"a+");
if(fout==NULL){
printf("outputfile[%s]cannotopen! ",argv[2]);
fclose(fin);
return-1;
}
/*
fin=fopen("in.txt","r");
fout=fopen("out.txt","a+");
*/
memset(line,0,sizeof(line));
linenum=0;
while(fgets(line,MAXLINE,fin)!=NULL){
++linenum;
freelink();
str=strtok(line,DIM);
if(str==NULL)break;
v=atoi(str);
inode(v);
while((str=strtok(NULL,DIM))!=NULL)
{
v=atoi(str);
inode(v);
}
prt2file(fout,linenum);
}
fclose(fin);
fclose(fout);
return0;
}
3. c语言编码规范
关于编码的规范，google为规范开源软件，开放了程序编码的文档。
网页的链接不知能否发上来，如果不能，自己查 Google C++ 风格指南，有中文版。http://yangyubo.com/google-cpp-styleguide/
4. 用c语言对字母编码程序设计
使用ASCII表, 大写A 是65 小写A 是97
中间相隔32
所以大写变小写 = 大写 + 32
所以小写变大写 = 小写 - 32
char cap = 'A';
char noncap = cap + 32;
在C/c++ 里, char 的类型是使用数字来记录, 然后使用相对的字母表, 如ASCII
5. 求c语言的一个程序编码
*
================================================
功能：选择排序
输入：数组名称（也就是数组首地址）、数组中元素个数
================================================
*/
/*
====================================================
算法思想简单描述：
在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环
到倒数第二个数和最后一个数比较为止。
选择排序是不稳定的。算法复杂度O(n2)--[n的平方]
=====================================================
*/
void
select_sort(int
*x,
int
n)
{
int
i,
j,
min,
t;
for
(i=0;
i<n-1;
i++)
/*要选择的次数：0~n-2共n-1次*/
{
min
=
i;
/*假设当前下标为i的数最小，比较后再调整*/
for
(j=i+1;
j<n;
j++)/*循环找出最小的数的下标是哪个*/
{
if
(*(x+j)
<
*(x+min))
{
min
=
j;
/*如果后面的数比前面的小，则记下它的下标*/
}
}
if
(min
!=
i)
/*如果min在循环中改变了，就需要交换数据*/
{
t
=
*(x+i);
*(x+i)
=
*(x+min);
*(x+min)
=
t;
}
}
}
/*
================================================
功能：直接插入排序
输入：数组名称（也就是数组首地址）、数组中元素个数
================================================
*/
/*
====================================================
算法思想简单描述：
在要排序的一组数中，假设前面(n-1)
[n>=2]
个数已经是排
好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数
也是排好顺序的。如此反复循环，直到全部排好顺序。
直接插入排序是稳定的。算法时间复杂度O(n2)--[n的平方]
=====================================================
*/
void
insert_sort(int
*x,
int
n)
{
int
i,
j,
t;
for
(i=1;
i<n;
i++)
/*要选择的次数：1~n-1共n-1次*/
{
/*
暂存下标为i的数。注意：下标从1开始，原因就是开始时
第一个数即下标为0的数，前面没有任何数，单单一个，认为
它是排好顺序的。
*/
t=*(x+i);
for
(j=i-1;
j>=0
&&
t<*(x+j);
j--)
/*注意：j=i-1，j--，这里就是下标为i的数，在它前面有序列中找插入位置。*/
{
*(x+j+1)
=
*(x+j);
/*如果满足条件就往后挪。最坏的情况就是t比下标为0的数都小，它要放在最前面，j==-1，退出循环*/
}
*(x+j+1)
=
t;
/*找到下标为i的数的放置位置*/
}
}
/*
================================================
功能：冒泡排序
输入：数组名称（也就是数组首地址）、数组中元素个数
================================================
*/
/*
====================================================
算法思想简单描述：
在要排序的一组数中，对当前还未排好序的范围内的全部数，自上
而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较
小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要
求相反时，就将它们互换。
下面是一种改进的冒泡算法，它记录了每一遍扫描后最后下沉数的
位置k，这样可以减少外层循环扫描的次数。
冒泡排序是稳定的。算法时间复杂度O(n2)--[n的平方]
=====================================================
*/
void
bubble_sort(int
*x,
int
n)
{
int
j,
k,
h,
t;
for
(h=n-1;
h>0;
h=k)
/*循环到没有比较范围*/
{
for
(j=0,
k=0;
j<h;
j++)
/*每次预置k=0，循环扫描后更新k*/
{
if
(*(x+j)
>
*(x+j+1))
/*大的放在后面，小的放到前面*/
{
t
=
*(x+j);
*(x+j)
=
*(x+j+1);
*(x+j+1)
=
t;
/*完成交换*/
k
=
j;
/*保存最后下沉的位置。这样k后面的都是排序排好了的。*/
}
}
}
}
/*
================================================
功能：希尔排序
输入：数组名称（也就是数组首地址）、数组中元素个数
================================================
*/
/*
====================================================
算法思想简单描述：
在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点，
并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离（称为
增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除
多个元素交换。D.L.shell于1959年在以他名字命名的排序算法中实现
了这一思想。算法先将要排序的一组数按某个增量d分成若干组，每组中
记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量
对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成
一组，排序完成。
下面的函数是一个希尔排序算法的一个实现，初次取序列的一半为增量，
以后每次减半，直到增量为1。
希尔排序是不稳定的。
=====================================================
*/
void
shell_sort(int
*x,
int
n)
{
int
h,
j,
k,
t;
for
(h=n/2;
h>0;
h=h/2)
/*控制增量*/
{
for
(j=h;
j<n;
j++)
/*这个实际上就是上面的直接插入排序*/
{
t
=
*(x+j);
for
(k=j-h;
(k>=0
&&
t<*(x+k));
k-=h)
{
*(x+k+h)
=
*(x+k);
}
*(x+k+h)
=
t;
}
}
}
/*
================================================
功能：快速排序
输入：数组名称（也就是数组首地址）、数组中起止元素的下标
================================================
*/
/*
====================================================
算法思想简单描述：
快速排序是对冒泡排序的一种本质改进。它的基本思想是通过一趟
扫描后，使得排序序列的长度能大幅度地减少。在冒泡排序中，一次
扫描只能确保最大数值的数移到正确位置，而待排序序列的长度可能只
减少1。快速排序通过一趟扫描，就能确保某个数（以它为基准点吧）
的左边各数都比它小，右边各数都比它大。然后又用同样的方法处理
它左右两边的数，直到基准点的左右只有一个元素为止。它是由
C.A.R.Hoare于1962年提出的。
显然快速排序可以用递归实现，当然也可以用栈化解递归实现。下面的
函数是用递归实现的，有兴趣的朋友可以改成非递归的。
快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n)，最坏O(n2)
=====================================================
*/
void
quick_sort(int
*x,
int
low,
int
high)
{
int
i,
j,
t;
if
(low
<
high)
/*要排序的元素起止下标，保证小的放在左边，大的放在右边。这里以下标为low的元素为基准点*/
{
i
=
low;
j
=
high;
t
=
*(x+low);
/*暂存基准点的数*/
while
(i<j)
/*循环扫描*/
{
while
(i<j
&&
*(x+j)>t)
/*在右边的只要比基准点大仍放在右边*/
{
j--;
/*前移一个位置*/
}
if
(i<j)
{
*(x+i)
=
*(x+j);
/*上面的循环退出：即出现比基准点小的数，替换基准点的数*/
i++;
/*后移一个位置，并以此为基准点*/
}
while
(i<j
&&
*(x+i)<=t)
/*在左边的只要小于等于基准点仍放在左边*/
{
i++;
/*后移一个位置*/
}
if
(i<j)
{
*(x+j)
=
*(x+i);
/*上面的循环退出：即出现比基准点大的数，放到右边*/
j--;
/*前移一个位置*/
}
}
*(x+i)
=
t;
/*一遍扫描完后，放到适当位置*/
quick_sort(x,low,i-1);
/*对基准点左边的数再执行快速排序*/
quick_sort(x,i+1,high);
/*对基准点右边的数再执行快速排序*/
}
}
/*
================================================
功能：堆排序
输入：数组名称（也就是数组首地址）、数组中元素个数
================================================
*/
/*
====================================================
算法思想简单描述：
堆排序是一种树形选择排序，是对直接选择排序的有效改进。
堆的定义如下：具有n个元素的序列（h1,h2,...,hn),当且仅当
满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)
时称之为堆。在这里只讨论满足前者条件的堆。
由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项。完全二叉树可以
很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。
初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储顺序，
使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点
交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点
的堆，并对它们作交换，最后得到有n个节点的有序序列。
从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素
交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数
实现排序的函数。
堆排序是不稳定的。算法时间复杂度O(nlog2n)。
*/
/*
功能：渗透建堆
输入：数组名称（也就是数组首地址）、参与建堆元素的个数、从第几个元素开始
*/
void
sift(int
*x,
int
n,
int
s)
{
int
t,
k,
j;
t
=
*(x+s);
/*暂存开始元素*/
k
=
s;
/*开始元素下标*/
j
=
2*k
+
1;
/*右子树元素下标*/
while
(j<n)
{
if
(j<n-1
&&
*(x+j)
<
*(x+j+1))/*判断是否满足堆的条件：满足就继续下一轮比较，否则调整。*/
{
j++;
}
if
(t<*(x+j))
/*调整*/
{
*(x+k)
=
*(x+j);
k
=
j;
/*调整后，开始元素也随之调整*/
j
=
2*k
+
1;
}
else
/*没有需要调整了，已经是个堆了，退出循环。*/
{
break;
}
}
*(x+k)
=
t;
/*开始元素放到它正确位置*/
}
/*
功能：堆排序
输入：数组名称（也就是数组首地址）、数组中元素个数
*/
void
heap_sort(int
*x,
int
n)
{
int
i,
k,
t;
int
*p;
for
(i=n/2-1;
i>=0;
i--)
{
sift(x,n,i);
/*初始建堆*/
}
for
(k=n-1;
k>=1;
k--)
{
t
=
*(x+0);
/*堆顶放到最后*/
*(x+0)
=
*(x+k);
*(x+k)
=
t;
sift(x,k,0);
/*剩下的数再建堆*/
}
}
void
main()
{
#define
MAX
4
int
*p,
i,
a[MAX];
/*录入测试数据*/
p
=
a;
printf("Input
%d
number
for
sorting
:\n",MAX);
for
(i=0;
i<MAX;
i++)
{
scanf("%d",p++);
}
printf("\n");
/*测试选择排序*/
p
=
a;
select_sort(p,MAX);
/**/
/*测试直接插入排序*/
/*
p
=
a;
insert_sort(p,MAX);
*/
/*测试冒泡排序*/
/*
p
=
a;
insert_sort(p,MAX);
*/
/*测试快速排序*/
/*
p
=
a;
quick_sort(p,0,MAX-1);
*/
/*测试堆排序*/
/*
p
=
a;
heap_sort(p,MAX);
*/
for
(p=a,
i=0;
i<MAX;
i++)
{
printf("%d
",*p++);
}
printf("\n");
system("pause");
}
6. 用C语言实现CRC编码程序
#include <stdio.h>
#include <string.h>
#include "stdlib.h"
unsigned int char2int(char *str)
{
unsigned int count=0, ret=0;
for(count = 0; count<strlen(str);count++)
{
ret = ret<<1;
if('0' != str[count])
{ ret+=1;}
}
return ret;
}
unsigned int getR(char *str)
{
unsigned int c =0 ;
int ret = strlen(str)-1;
for(c=0;c < strlen(str);c++)
{if(str[c] != '0')<br/> {return ret-c;}
}
}
int getRi(unsigned int num)
{
int c =0;
for(;num != 0; c++)
{num = num>>1;}
return c;
}
void CRC(char *scode, char *p, char*g )
{
unsigned int iP = char2int(p);
unsigned int iG = char2int(g);
unsigned int r= getR(g);
unsigned int code = iP << r;
unsigned int yx = code;
for(;getRi(yx) >= getRi(iG);)
{ yx = yx ^ (iG<<(getRi(yx) - getRi(iG)));}
code += yx;
itoa(code,scode,2);
}
void main() //定义主函数
{
char data[8]="" , bds[8]="",code[16]="";
printf("数据：");
scanf("%s", data);
printf("表达式：");
scanf("%s", bds);
CRC(code,data,bds);
printf("编码：%s",code);
}
7. 用C语言编码程序 a+b=c 谢谢
话不多说，接下来是代码：
#include<stdio.h>
int
main()
{
int
a,b,c;
printf("请输入第一个数A的值：");
scanf("%d",&a);
printf("请输入第一个数B的值：");
scanf("%d",&b);
c=a+b;
printf("C的值为：%d",c);
getchar();//这是防止程序一闪而过添加的一个按回车的函数，得到结果后按回车程序才会结束。。
getchar();
return
0;
}
8. 在pic中如何用C语言编写程序
//09/10/24
//lcd1602显示时间 日期 星期 温度
//通过按键校时：K10--小时，K11--分钟，K12--秒（归零），K13-星期，BR1--年，RB2--月，RB3--日。
//芯片要求：PIC16F877A
#include<pic.h> //包含单片机内部资源预定义
__CONFIG(0x1832);
//芯片配置字，看门狗关，上电延时开，掉电检测关，低压编程关，加密，4M晶体HS振荡
#define i_o RB4 //定义DS1302的数据口
#define sclk RB0 //定义DS1302的时钟口
#define rst RB5 //定义DS1302的复位口
#define rs RA1 //1602
#define rw RA2
#define e RA3
# define DQ RA0 //定义18B20数据端口
unsigned char TLV=0 ; //采集到的温度高8位
unsigned char THV=0; //采集到的温度低8位
unsigned char ;
unsigned char shi; //整数十位
unsigned char ge; //整数个位
unsigned char shifen; //十分位
float temp;
void display();
//定义读取时间和日期存放表格
char table1[7];
//定义0-9的显示代码
const char table2[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
unsigned char rx_data,read_data,count,sec,min,hour,day,mon,week,year,time;
//----------------------------------------------
//ds18b20部分
//------------------------------------------------
//延时函数
void delay1(unsigned int x)
{
unsigned int i;
for(i=x;i>0;i--);
}
//------------------------------------------------
//延时函数
void delay2(char x,char y)
{
char z;
do{
z=y;
do{;}while(--z);
}while(--x);
}
//其指令时间为：7+（3*（Y-1）+7）*（X-1）如果再加上函数调用的call 指令、页面设定、传递参数花掉的7 个指令。
//则是：14+（3*（Y-1）+7）*（X-1）。
//***************************************
//初始化ds18b20
void ds18b20_init()
{
char presence=1;
while(presence)
{
TRISA0=0; //主机拉至低电平
DQ=0;
delay2(2,99); //延时503us
TRISA0=1; //释放总线等电阻拉高总线,并保持15~60us
delay2(2,8); //延时70us
if(DQ==1) presence=1; //没有接收到应答信号，继续复位
else presence=0; //接收到应答信号
delay2(2,60); //延时430us
}
}
//*****************************************************
//写ds18b20
void ds18b20_write_byte(unsigned char code)
{
unsigned char i,k;
for(i=8;i>0;i--)
{
k=code&0x01;
TRISA0=0;
DQ=0; //数据线拉低产生时间片
asm("nop");
asm("nop");
if(k) DQ=1; //写1则拉高数据电平
delay1(3); //延时42us，ds18b20对数据线采样
asm("nop");
TRISA0=1; //采样结束，释放总线，拉高电平
code=code>>1;
delay1(7); //延时82us
}
}
//****************************************************
//读ds18b20
unsigned char ds18b20_read_byte()
{
unsigned char i,k;
for(i=8;i>0;i--)
{
k=k>>1;
TRISA0=0;
DQ=0; //数据线拉低再拉高产生读时间片
asm("nop");
asm("nop");
TRISA0=1;
asm("nop");
asm("nop");
if(DQ) k=k|0x80; //15us内要完成读位
delay1(6); //延时72us后释放总线
}
return (k);
}
//********************************************
//启动温度转换函数
void get_temp()
{
int i;
signed int t;
TRISA0=1;
ds18b20_init(); //复位等待从机应答
ds18b20_write_byte(0XCC); //忽略ROM匹配
ds18b20_write_byte(0X44); //发送温度转化命令
for(i=2;i>0;i--)
{
display(); //调用多次显示函数，确保温度转换完成所需要的时间
}
ds18b20_init(); //再次复位，等待从机应答
ds18b20_write_byte(0XCC); //忽略ROM匹配
ds18b20_write_byte(0XBE); //发送读温度命令
TLV=ds18b20_read_byte(); //读出温度低8
THV=ds18b20_read_byte(); //读出温度高8位
TRISA0=1; //释放总线
t=THV<<8;
t=t|TLV;
if(t<0) //负温度
{
temp=(~t+1)*0.0625*10+0.5; //负温度时，取反加1再乘以0.0625得实际温度，乘10+0.5显示小数点一位，且四舍五入
}
else
temp=t*0.0625*10+0.5; //正温度
if(t<0)
='-'; //负温度时百位显示负号
else
=(const) temp/1000+0x30; //百位
shi=((const) temp%1000)/100; //十位
ge=((const) temp%1000)%100/10; //个位
shifen=((const) temp%1000)%100%10; //十分位
NOP();
}
//---------------------------------------------
//------------DS1303部分-----------------------
//---------------------------------------------
//延时程序
void delay() //延时程序
{
int i; //定义整形变量
for(i=0x64;i--;); //延时
}
//写一个字节数据函数
void write_byte(unsigned char data)
{
int j; //设置循环变量
for(j=0;j<8;j++) //连续写8bit
{
i_o=0; //先设置数据为0
sclk=0; //时钟信号拉低
if(data&0x01) //判断待发送的数据位是0或1
{
i_o=1; //待发送数据位是1
}
data=data>>1; //待发送的数据右移1位
sclk=1; //拉高时钟信号
}
sclk=0; //写完一个字节，拉低时钟信号
}
//---------------------------------------------
//读一个字节函数
unsigned char read_byte()
{
int j; //设置循环变量
TRISB4=1; //设置数据口方向为输入
for(j=8;j--;) //连续读取8bit
{
sclk=0; //拉低时钟信号
rx_data=rx_data>>1; //接收寄存器右移1位
if(i_o==1) rx_data=rx_data|0x80;
sclk=1; //拉高时钟信号
}
TRISB4=0; //恢复数据口方向为输出
sclk=0; //拉低时钟信号
return(rx_data); //返回读取到的数据
}
//----------------------------------------------
//写DS1302
void write_ds1302(unsigned char addr,unsigned char code)
{
rst=0;
sclk=0;
rst=1;
write_byte(addr);
write_byte(code);
sclk=0;
rst=1;
}
//-------------------------------------------
//读DS1302
void read_ds1302(unsigned char addr)
{
rst=0;
sclk=0;
rst=1;
write_byte(addr);
read_data=read_byte();
//return read_data;
}
//---------------------------------------------
//读取时间函数
void get_time()
{
int i; //设置循环变量
rst=1; //使能DS1302
write_byte(0xbf); //发送多字节读取命令
for(i=0;i<7;i++) //连续读取7个字节数据
{
table1[i]=read_byte(); //调用读取1个字节数据的函数
}
rst=0; //复位DS1302
}
//DS1302初始化函数
void ds1302_init()
{
sclk=0; //拉低时钟信号
rst =0; //复位DS1302
rst=1; //使能DS1302
write_ds1302(0x8e,0); //发控制命令
rst=0; //复位
}
//---------------------------------------------
//设置时间函数
void set_time()
{
//定义待设置的时间： 秒、 分、 时、 日、月、星期、年、控制字
const char table[]={0x00,0x00,0x12,0x23,0x10,0x05,0x09,0x00};
int i; //定义循环变量
rst=1; //使能DS1302
write_byte(0xbe); //时钟多字节写命令
for(i=0;i<8;i++) //连续写8个字节数据
{
write_byte(table[i]); //调用写一个字节函数
}
rst=0; //复位
}
//-------------------------------------------
//8位二进制数转换为十进制数
void two_to_ten(unsigned char i)
{
time=(table1[i]&0x0f)+(table1[i]>>4)*0x0a;
}
//-------------------------------------------
//十进制数转换为BCD码
void ten_to_bcd(unsigned char i)
{
time=((i/0x0a)<<4)|(i%0x0a);
}
//------------------------------------------
//校时程序
void change_time()
{
if(RC0==0) //改变星期---k13
{
delay();
if(RC0==0)
{
if(count==0)
{
count=1;
two_to_ten(5);
week=time;
week++;
if(week>=8)
{
week==1;
write_ds1302(0x8A,1);
}
else
write_ds1302(0x8A,week);
}
}
}
else if(RC1==0) //秒归零--k12
{
delay();
if(RC1==0)
{
if(count==0)
{
count=1;
write_ds1302(0x80,0);
}
}
}
else if(RC2==0) //改变分位--k11
{
delay();
if(RC2==0)
{
if(count==0)
{
count=1;
two_to_ten(1);//BCD码转换成十进制数
min=time;
min++;
if(min>=60)
{
min=0;
write_ds1302(0x82,min);
}
else
{
ten_to_bcd(min);//十进制数转换为BCD码存进DS1302
write_ds1302(0x82,time);
}
}
}
}
else if(RC3==0) //改变小时位--k10
{
delay();
if(RC3==0)
{
if(count==0)
{
count=1;
two_to_ten(2);//BCD码转换成十进制数
hour=time;
hour++;
if(hour>=24)
{
hour=0;
write_ds1302(0x84,hour);
}
else
{
ten_to_bcd(hour);
write_ds1302(0x84,time);
}
}
}
}
else if(RB2==0)
{
delay();
if(RB2==0)
{
if(count==0)
{
count=1;
two_to_ten(4);//BCD码转换成十进制数
mon=time;
mon++;
if(mon>=13)
{
mon=1;
write_ds1302(0x88,mon);
}
else
{
ten_to_bcd(mon);
write_ds1302(0x88,time);
}
}
}
}
else if(RB3==0)
{
delay();
if(RB3==0)
{
if(count==0)
{
count=1;
two_to_ten(3);//BCD码转换成十进制数
day=time;
day++;
if((table1[6]%4==0)&&(table1[4]==2)&&(day>=30)) //润年2月
{
day=1;
write_ds1302(0x86,day);
}
else if(((table1[6]%4)!=0)&&(table1[4]==2)&&(day>=29))//非润年的2月
{
day=1;
write_ds1302(0x86,day);
}
else if(((table1[4]==1)||(table1[4]==3)||(table1[4]==5)||(table1[4]==7)||(table1[4]==8)||(table1[4]==0x10)||(table1[4]==0x12))&&(day>=32))
{
day=1;
write_ds1302(0x86,day);
}
else if(((table1[4]==4)||(table1[4]==6)||(table1[4]==9)||(table1[4]==0x11))&&(day>=31))
{
day=1;
write_ds1302(0x86,day);
}
else
{
ten_to_bcd(day);
write_ds1302(0x86,time);
}
}
}
}
else if(RB1==0)
{
delay();
if(RB1==0)
{
if(count==0)
{
count=1;
two_to_ten(6);//BCD码转换成十进制数
year=time;
year++;
if(year>=16)
{
year=0x00;
write_ds1302(0x8c,0);
}
else
{
ten_to_bcd(year);
write_ds1302(0x8c,time);
}
}
}
}
else
count=0;
}
//****************************************
//**************lcd1602*******************
//****************************************
//延时程序
//void delay()
// {
// unsigned char i;
// for(i=100;i>0;i--);
// }
//****************************************
//LCD写一个字节数据
void write_lcd(unsigned char code)
{
PORTD=code;
rs=1;
rw=0;
e=0;
delay();
e=1;
}
//****************************************
//lcd写命令函数
void lcd_enable(unsigned char code)
{
PORTD=code;
rs=0;
rw=0;
e=0;
delay();
e=1;
}
//*****************************************
//lcd显示设置
void lcd_init()
{
lcd_enable(0x01); //清除显示
lcd_enable(0x38); //设置16X2显示，5X7点阵
lcd_enable(0x0c); //开显示，不显示光标
lcd_enable(0x06); //光标左移
}
//-------------------------------------------
//显示函数
void display()
{
// PORTD=0X80; //小时
lcd_enable(0X80);
write_lcd((table1[2]>>4)+0x30);
// PORTD=0x81;
lcd_enable(0x81);
write_lcd((table1[2]&0x0f)+0x30);
// PORTD=0X82;
lcd_enable(0X82);
write_lcd(':');
// PORTD=0X83; //分
lcd_enable(0X83);
write_lcd((table1[1]>>4)+0x30);
// PORTD=0x84;
lcd_enable(0x84);
write_lcd((table1[1]&0x0f)+0x30);
// PORTD=0X85;
lcd_enable(0X85);
write_lcd(':');
// PORTD=0X86; //秒
lcd_enable(0X86);
write_lcd((table1[0]>>4)+0x30);
// PORTD=0x87;
lcd_enable(0x87);
write_lcd((table1[0]&0x0f)+0x30);
// PORTD=0X89; //温度的百位
lcd_enable(0X89);
write_lcd();
// PORTD=0X8a; //温度的十位
lcd_enable(0X8a);
write_lcd(shi+0x30);
// PORTD=0X8b; //温度的个位
lcd_enable(0X8b);
write_lcd(ge+0x30);
// PORTD=0X8c;
lcd_enable(0X8c);
write_lcd('.');
// PORTD=0X8d; //温度的十分位
lcd_enable(0X8d);
write_lcd(shifen+0x30);
// PORTD=0X8e; //显示'C'
lcd_enable(0X8e);
write_lcd('C');
//
// PORTD=0XC0; //年
lcd_enable(0XC0);
write_lcd((table1[6]>>4)+0x30);
//PORTD=0XC1;
lcd_enable(0XC1);
write_lcd((table1[6]&0x0f)+0x30);
// PORTD=0XC2;
lcd_enable(0XC2);
write_lcd('-');
// PORTD=0XC3; //月
lcd_enable(0XC3);
write_lcd((table1[4]>>4)+0x30);
// PORTD=0xC4;
lcd_enable(0xC4);
write_lcd((table1[4]&0x0f)+0x30);
// PORTD=0XC5;
lcd_enable(0XC5);
write_lcd('-');
// PORTD=0XC6; //日
lcd_enable(0XC6);
write_lcd((table1[3]>>4)+0x30);
// PORTD=0xC7;
lcd_enable(0xC7);
write_lcd((table1[3]&0x0f)+0x30);
// PORTD=0XCD; //星期
lcd_enable(0XCD);
write_lcd((table1[5]&0x0f)+0x30);
}
//--------------------------------------------
//引脚定义函数
void port_init()
{
TRISA=0x00; //设置A口全输出
TRISD=0X00; //设置D口全输出
ADCON1=0X06; //设置A口为普通I/O口
TRISB=0X0E; //
OPTION=0X00; //开启B口弱上拉
PORTA=0XFF;
PORTD=0XFF; //先熄灭所有显示
lcd_init();
TRISC=0XEF; //RC3输出，其他为输入
PORTC=0XEF;
count=0;
}
//----------------------------------------------
//主函数
void main()
{
port_init(); //调用引脚初始化函数
read_ds1302(0x81); //查看DS1302是否起振
if(read_data&0x80) //否，则初始化DS1302
{
ds1302_init(); //调用DS1302初始化函数
set_time(); //调用设置时间函数
}
while(1)
{
get_time(); //调用取时间函数
change_time();
get_temp(); //调用温度转换函数
display(); //调用显示函数
}
}
9. c语言设计简单计算机程序编码
#include<iostream>
using namespace std;
int main()
{
cout《“HELLO WORLD”《endl；
return 0；
}
10. 用c语言实现算术编码和解码
/*我觉得应该是你相互换吧？*/
void code(char *p)
{
*p+=5;/*相应加5个数字我觉得字母不可能存在大于250的哈*/
}
void codec(char *p)
{*p-=5;}
main()
{
char a[100];
int i;
printf("Enter the string!\n");
scanf("%s",a);/*输入字符*/
for(i=0;a[i]!='\0';i++)
{
code(a+i);/*加密*/
}
printf("\ncode string is:%s",a);
for(i=0;a[i]!='\0';i++)
{codec(a+i);}
printf("\nenter string is:%s",a);
}