本文目录一览：
- 1、求大神们帮忙！！单片机ATmega8515读取RTC(DS1302)的时间信息的C语言程序，只要读秒，分，时，这三个信息
- 2、c语言switch问题/单片机
- 3、c语言 建立一个链表，实现增删改查
- 4、C#中怎么复制数组
- 5、在C#中,采用什么属性表示数组的维数
- 6、怎样用C语言做一个按钮并设置点击反应
求大神们帮忙！！单片机ATmega8515读取RTC(DS1302)的时间信息的C语言程序，只要读秒，分，时，这三个信息
#includereg52.h //包含单片机寄存器的头文件
#includeintrins.h //包含_nop_()函数定义的头文件
unsigned char code digit[10]={"0123456789"}; //定义字符数组显示数字
sbit SCLK=P1^0; //位定义1302芯片的接口，时钟输出端口定义在P1.0引脚
sbit DATA=P1^1; //位定义1302芯片的接口，数据输出端定义在P1.1引脚
sbit RST=P1^2; //位定义1302芯片的接口，复位端口定义在P1.2引脚
/*****************************************************
函数功能：延时若干微秒
入口参数：n
***************************************************/
void delaynus(unsigned char n)
{
unsigned char i;
for(i=0;in;i++);
}
/*****************************************************
函数功能：向1302写一个字节数据
入口参数：x
***************************************************/
void Write1302(unsigned char dat)
{
unsigned char i;
SCLK=0; //拉低SCLK，为脉冲上升沿写入数据做好准备
delaynus(2); //稍微等待，使硬件做好准备
for(i=0;i8;i++) //连续写8个二进制位数据
{
DATA=dat0x01; //取出dat的第0位数据写入1302 低位在前
，高位在后
delaynus(2); //稍微等待，使硬件做好准备
SCLK=1; //上升沿写入数据
delaynus(2); //稍微等待，使硬件做好准备
SCLK=0; //重新拉低SCLK，形成脉冲
dat=1; //将dat的各数据位右移1位，准备写入
下一个数据位
}
}
/*****************************************************
函数功能：根据命令字，向1302写一个字节数据
入口参数：Cmd，储存命令字；dat，储存待写的数据
***************************************************/
void WriteSet1302(unsigned char Cmd,unsigned char dat)
{
RST=0; //禁止数据传递
SCLK=0; //确保写数居前SCLK被拉低
RST=1; //启动数据传输
delaynus(2); //稍微等待，使硬件做好准备
Write1302(Cmd); //写入命令字
Write1302(dat); //写数据
SCLK=1; //将时钟电平置于高电平状态
RST=0; //禁止数据传递
}
/*****************************************************
函数功能：从1302读一个字节数据
入口参数：x
***************************************************/
unsigned char Read1302(void)
{
unsigned char i,dat;
delaynus(2); //稍微等待，使硬件做好准备
for(i=0;i8;i++) //连续读8个二进制位数据
{ dat=1;
if(DATA==1) //如果读出的数据是1
dat|=0x80; //将1取出，写在dat的最高位
SCLK=1; //将SCLK置于高电平，为下降沿读出
delaynus(2); //稍微等待
SCLK=0; //拉低SCLK，形成脉冲下降沿
delaynus(2); //稍微等待
}
return dat; //将读出的数据返回
}
/*****************************************************
函数功能：根据命令字，从1302读取一个字节数据
入口参数：Cmd
***************************************************/
unsigned char ReadSet1302(unsigned char Cmd)
{
unsigned char dat;
RST=0; //拉低RST
SCLK=0; //确保写数居前SCLK被拉低
RST=1; //启动数据传输
Write1302(Cmd); //写入命令字
dat=Read1302(); //读出数据
SCLK=1; //将时钟电平置于已知状态
RST=0; //禁止数据传递
return dat; //将读出的数据返回
}
/*****************************************************
函数功能： 1302进行初始化设置
***************************************************/
void Init_DS1302(void)
{
unsigned char flag;
flag= ReadSet1302(0x81);
if(flag0x80) { //判断时钟芯片是否关闭
WriteSet1302(0x8E,0x00); //根据写状态寄存器命令
字，写入不保护指令
WriteSet1302(0x80,((55/10)4|(55%10))); //根据写秒寄存器命
令字，写入秒的初始值
WriteSet1302(0x82,((59/10)4|(59%10))); //根据写分寄存器命
令字，写入分的初始值
WriteSet1302(0x84,((23/10)4|(23%10))); //根据写小时寄存器命
令字，写入小时的初始值
WriteSet1302(0x86,((18/10)4|(18%10))); //根据写日寄存器命令
字，写入日的初始值
WriteSet1302(0x88,((6/10)4|(6%10))); //根据写月寄存器命令字
，写入月的初始值
WriteSet1302(0x8c,((9/10)4|(9%10))); //根据写年寄存器命令
字，写入年的初始值
WriteSet1302(0x90,0xa5); //打开充电功能 选择2K
电阻充电方式
WriteSet1302(0x8E,0x80); //根据写状
态寄存器命令字，写入保护指令
}
}
//如果不想每次都初始化时间，也就是掉电后还想让时钟继续走时的话 就用
上面的语句
/*--------------------这是每次都初始化的语句-----------------*/
/*
WriteSet1302(0x8E,0x00); //根据写状态寄存器命令字
，写入不保护指令
WriteSet1302(0x80,((55/10)4|(55%10))); //根据写秒寄存器命令字
，写入秒的初始值
WriteSet1302(0x82,((59/10)4|(59%10))); //根据写分寄存器命
令字，写入分的初始值
WriteSet1302(0x84,((23/10)4|(23%10))); //根据写小时寄存器命
令字，写入小时的初始值
WriteSet1302(0x86,((18/10)4|(18%10))); //根据写日寄存器命令
字，写入日的初始值
WriteSet1302(0x88,((6/10)4|(6%10))); //根据写月寄存器命令字
，写入月的初始值
WriteSet1302(0x8c,((9/10)4|(9%10))); //根据写年寄存器命令
字，写入年的初始值
WriteSet1302(0x90,0xa5); //打开充电功能 选择2K
电阻充电方式
WriteSet1302(0x8E,0x80); //根据写状态寄存器命令
字，写入保护指令
*/
/********************************************************************
***********
以下是对液晶模块的操作程序
*********************************************************************
**********/
sbit RS=P2^0; //寄存器选择位，将RS位定义为P2.0引脚
sbit RW=P2^1; //读写选择位，将RW位定义为P2.1引脚
sbit E=P2^2; //使能信号位，将E位定义为P2.2引脚
sbit BF=P0^7; //忙碌标志位，，将BF位定义为P0.7引脚
/*****************************************************
函数功能：延时1ms
(3j+2)*i=(3×33+2)×10=1010(微秒)，可以认为是1毫秒
***************************************************/
void delay1ms()
{
unsigned char i,j;
for(i=0;i10;i++)
for(j=0;j33;j++)
;
}
/*****************************************************
函数功能：延时若干毫秒
入口参数：n
***************************************************/
void delaynms(unsigned char n)
{
unsigned char i;
for(i=0;in;i++)
delay1ms();
}
/*****************************************************
函数功能：判断液晶模块的忙碌状态
返回值：result。result=1，忙碌;result=0，不忙
***************************************************/
bit BusyTest(void)
{
bit result;
RS=0; //根据规定，RS为低电平，RW为高电平时，可以读
状态
RW=1;
E=1; //E=1，才允许读写
_nop_(); //空操作
_nop_();
_nop_();
_nop_(); //空操作四个机器周期，给硬件反应时间
result=BF; //将忙碌标志电平赋给result
E=0; //将E恢复低电平
return result;
}
/*****************************************************
函数功能：将模式设置指令或显示地址写入液晶模块
入口参数：dictate
***************************************************/
void WriteInstruction (unsigned char dictate)
{
while(BusyTest()==1); //如果忙就等待
RS=0; //根据规定，RS和R/W同时为低电平时，可
以写入指令
RW=0;
E=0; //E置低电平(根据表8-6，写指令时，E为
高脉冲，
// 就是让E从0到1发生正跳变，所以应先置"0"
_nop_();
_nop_(); //空操作两个机器周期，给硬件反应时间
P0=dictate; //将数据送入P0口，即写入指令或地址
_nop_();
_nop_();
_nop_();
_nop_(); //空操作四个机器周期，给硬件反应时间
E=1; //E置高电平
_nop_();
_nop_();
_nop_();
_nop_(); //空操作四个机器周期，给硬件反应时间
E=0; //当E由高电平跳变成低电平时，液晶模块
开始执行命令
}
/*****************************************************
函数功能：指定字符显示的实际地址
入口参数：x
***************************************************/
void WriteAddress(unsigned char x)
{
WriteInstruction(x|0x80); //显示位置的确定方法规定为"80H+地址码
x"
}
/*****************************************************
函数功能：将数据(字符的标准ASCII码)写入液晶模块
入口参数：y(为字符常量)
***************************************************/
void WriteData(unsigned char y)
{
while(BusyTest()==1);
RS=1; //RS为高电平，RW为低电平时，可以写入数据
RW=0;
E=0; //E置低电平(根据表8-6，写指令时，E为高脉冲
，
// 就是让E从0到1发生正跳变，所以应先置"0"
P0=y; //将数据送入P0口，即将数据写入液晶模块
_nop_();
_nop_();
_nop_();
_nop_(); //空操作四个机器周期，给硬件反应时间
E=1; //E置高电平
_nop_();
_nop_();
_nop_();
_nop_(); //空操作四个机器周期，给硬件反应时间
E=0; //当E由高电平跳变成低电平时，液晶模块开始执
行命令
}
/*****************************************************
函数功能：对LCD的显示模式进行初始化设置
***************************************************/
void LcdInitiate(void)
{
delaynms(15); //延时15ms，首次写指令时应给LCD一段较
长的反应时间
WriteInstruction(0x38); //显示模式设置：16×2显示，5×7点阵，
8位数据接口
delaynms(5); //延时5ms ，给硬件一点反应时间
WriteInstruction(0x38);
delaynms(5); //延时5ms ，给硬件一点反应时间
WriteInstruction(0x38); //连续三次，确保初始化成功
delaynms(5); //延时5ms ，给硬件一点反应时间
WriteInstruction(0x0c); //显示模式设置：显示开，无光标，
光标不闪烁
delaynms(5); //延时5ms ，给硬件一点反应时间
WriteInstruction(0x06); //显示模式设置：光标右移，字符不
移
delaynms(5); //延时5ms ，给硬件一点反应时间
WriteInstruction(0x01); //清屏幕指令，将以前的显示内容清
除
delaynms(5); //延时5ms ，给硬件一点反应时间
}
/**************************************************************
以下是1302数据的显示程序
**************************************************************/
/*****************************************************
函数功能：显示秒
入口参数：x
***************************************************/
void DisplaySecond(unsigned char x)
{
unsigned char i,j; //j,k分别储存十位和个位
i=x/10;//取十位
j=x%10;//取个位
WriteAddress(0x49); //写显示地址,将在第2行第7列开始显示
WriteData(digit[i]); //将百位数字的字符常量写入LCD
WriteData(digit[j]); //将十位数字的字符常量写入LCD
delaynms(50); //延时1ms给硬件一点反应时间
}
/*****************************************************
函数功能：显示分钟
入口参数：x
***************************************************/
void DisplayMinute(unsigned char x)
{
unsigned char i,j; //j,k十位和个位
i=x/10;//取十位
j=x%10;//取个位
WriteAddress(0x46); //写显示地址,将在第2行第7列开始显示
WriteData(digit[i]); //将百位数字的字符常量写入LCD
WriteData(digit[j]); //将十位数字的字符常量写入LCD
delaynms(50); //延时1ms给硬件一点反应时间
}
/*****************************************************
函数功能：显示小时
入口参数：x
***************************************************/
void DisplayHour(unsigned char x)
{
unsigned char i,j; //j,k十位和个位
i=x/10;//取十位
j=x%10;//取个位
WriteAddress(0x43); //写显示地址,将在第2行第7列开始显示
WriteData(digit[i]); //将百位数字的字符常量写入LCD
WriteData(digit[j]); //将十位数字的字符常量写入LCD
delaynms(50); //延时1ms给硬件一点反应时间
}
/*****************************************************
函数功能：显示日
入口参数：x
***************************************************/
void DisplayDay(unsigned char x)
{
unsigned char i,j; //j,k十位和个位
i=x/10;//取十位
j=x%10;//取个位
WriteAddress(0x0c); //写显示地址,将在第2行第7列开始显示
WriteData(digit[i]); //将十位数字的字符常量写入LCD
WriteData(digit[j]); //将个位数字的字符常量写入LCD
delaynms(50); //延时1ms给硬件一点反应时间
}
/*****************************************************
函数功能：显示月
入口参数：x
***************************************************/
void DisplayMonth(unsigned char x)
{
unsigned char i,j; //j,k分别储存十位和个位
i=x/10;//取十位
j=x%10;//取个位
WriteAddress(0x09); //写显示地址,将在第2行第7列开始显示
WriteData(digit[i]); //将十位位数字的字符常量写入LCD
WriteData(digit[j]); //将个位数字的字符常量写入LCD
delaynms(50); //延时1ms给硬件一点反应时间
}
/*****************************************************
函数功能：显示年
入口参数：x
***************************************************/
void DisplayYear(unsigned char x)
{
unsigned char i,j; //j,k分别储存十位和个位
i=x/10;//取十位
j=x%10;//取个位
WriteAddress(0x06); //写显示地址,将在第2行第7列开始显示
WriteData(digit[i]); //将十位位数字的字符常量写入LCD
WriteData(digit[j]); //将个位数字的字符常量写入LCD
delaynms(50); //延时1ms给硬件一点反应时间
}
/*****************************************************
函数功能：主函数
***************************************************/
void main(void)
{
unsigned char second,minute,hour,day,month,year; //分别储存苗
、分、小时，日，月，年
unsigned char ReadValue; //储存从1302读取的数据
LcdInitiate(); //将液晶初始化
WriteAddress(0x01); //写Date的显示地址,将在第1行第2列开始显示
WriteData('D'); //将字符常量写入LCD
WriteData('a'); //将字符常量写入LCD
WriteData('t'); //将字符常量写入LCD
WriteData('e'); //将字符常量写入LCD
WriteData(':'); //将字符常量写入LCD
WriteAddress(0x08); //写年月分隔符的显示地址， 显示在第1行第9列
WriteData('-'); //将字符常量写入LCD
WriteAddress(0x0b); //写月日分隔符的显示地址， 显示在第1行第12列
WriteData('-'); //将字符常量写入LCD
WriteAddress(0x45); //写小时与分钟分隔符的显示地址， 显示在第2行第
6列
WriteData(':'); //将字符常量写入LCD
WriteAddress(0x48); //写分钟与秒分隔符的显示地址， 显示在第2行第9
列
WriteData(':'); //将字符常量写入LCD
Init_DS1302(); //将1302初始化
while(1)
{
ReadValue = ReadSet1302(0x81); //从秒寄存器读数据
second=((ReadValue0x70)4)*10 + (ReadValue0x0F);//将读出数据
转化
DisplaySecond(second); //显示秒
ReadValue = ReadSet1302(0x83); //从分寄存器读
minute=((ReadValue0x70)4)*10 + (ReadValue0x0F); //将读出数据
转化
DisplayMinute(minute); //显示分
ReadValue = ReadSet1302(0x85); //从分寄存器读
hour=((ReadValue0x70)4)*10 + (ReadValue0x0F); //将读出数据转
化
DisplayHour(hour); //显示小时
ReadValue = ReadSet1302(0x87); //从分寄存器读
day=((ReadValue0x70)4)*10 + (ReadValue0x0F); //将读出数据转
化
DisplayDay(day); //显示日
ReadValue = ReadSet1302(0x89); //从分寄存器读
month=((ReadValue0x70)4)*10 + (ReadValue0x0F); //将读出数据
转化
DisplayMonth(month); //显示月
ReadValue = ReadSet1302(0x8d); //从分寄存器读
year=((ReadValue0xf0)4)*10 + (ReadValue0x0F); //将读出数据转
化
DisplayYear(year); //显示年
}
}
c语言switch问题/单片机
首先告诉你，这不是一个循环程序!使用switch只是相当于if ....else.... 程序是判断wenum的值，wenum的值是0,1,2,3,4,5中的一个。当wenum=0时执行case 0:后面语句遇到break就跳出!，后面的依次类推。 如果是在单片机中，循环一般是在while(1)中来完成的，整个switch应该是循环体中的一部分你的s++也应该是在一个循环语句中实现的，或者在定时器中断中实现。总之要保证s++反复执行!
c语言 建立一个链表，实现增删改查
下面是以前写的一个关于链表的综合操作，你可以看看，应该可以满足你的要求。
/********************************************************************
created: 2009/09/15
created: 16:9:2009 17:20
filename: E:\dd\lianbiao\lianbiao.cpp
author:
purpose: 一个win32 的控制台程序
实现单项链表的数据删除、插入、排序等功能
*********************************************************************/
#include stdio.h
#include "windows.h"
#include "malloc.h"
#define LEN sizeof(struct student)
#define NULL 0
#define N 5 //N为所要创建的链表的长度
int n = 0; //定义全局变量n，表示链表的节点个数
/*******************************************************************
Author/data: /2009/09/15
Description: 声明一个结构体作为链表的节点.
tip: student 只是一个标签,是不能声明变量的
*********************************************************************/
struct student
{
int num;
float cj;
struct student *Pnext;
};
/*******************************************************************
Author/data: /2009/09/15
Description: 创建一个动态链表
参数: 返回链表的第一个节点的地址
x 为链表的长度
*********************************************************************/
struct student *pa(int x)
{
struct student *head;
struct student *p1,*p2;
// n = 0;
p1 = p2 = (struct student *)malloc(LEN); //开辟一个结构体内存
fflush(stdin); // 清除缓冲区数据 避免直接读入缓冲区数据
scanf("%d,%f",p1-num,p1-cj);
head = NULL;
while(p1-Pnext != NULL)
{
n = n+1;
if(n == 1)
{
head = p1; // 链表的头地址
}
else
{
p2-Pnext = p1; //链接链表数据
}
/* 判断是否最后一个 */
if(n = x)
{
p1-Pnext = NULL;
}
else
{
p2 = p1;
p1 = (struct student *)malloc(LEN);
fflush(stdin);
scanf("%d,%f",p1-num,p1-cj);
}
}
return(head);
}
/*******************************************************************
Author/data: /2009/09/15
Description: 输出一个链表
参数: head为第一个节点的地址
*********************************************************************/
void print(struct student *head)
{
struct student *p;
int i = 0;
printf("\nNow,These %d records are:\n",n);
p = head;
if(head != NULL) // 如果链表不是空的，则进行数据输出
{
do
{
printf("%d\t",i++);
printf("%5d %5.1f\n",p-num,p-cj); // 输出链表数据
p = p-Pnext;
}while(p != NULL);
}
}
/*******************************************************************
Author/data: /2009/09/16
Description: 释放动态链表的地址空间
参数: 链表的头地址head
无返回值
*********************************************************************/
void freelinkspace(struct student *head)
{
struct student Ltemp;
Ltemp.Pnext = head-Pnext; // Ltemp 用来存放-next,避免空间被
// 释放后,找不到下一个结点的地址
while(head-Pnext != NULL) // 判断是否已经空间释放到最后一个
{
free(head);
head = Ltemp.Pnext;
Ltemp.Pnext = head-Pnext;
}
free(head); // 释放最后一个结点空间
}
/*******************************************************************
Author/data: /2009/09/15
Description: 删除链表链表中的一个结点
参数: head 为第一个节点的地址
num 为要删除结点的序号（head-num）
*********************************************************************/
struct student *del(struct student *head,int num)
{
struct student *p1,*p2;
p1 = head;
while(p1-num!=num p1-Pnext!=NULL) // 寻找要删除的结点
{
p2 = p1; // p2 存放删除结点的前一个结点地址
p1 = p1-Pnext; // p1 存放要删除的结点
}
if(num == p1-num) // 是否找到要删除结点
{
if(p1 == head) // 删除的是第一个结点
{
head = p1-Pnext;
}
else if(p1-Pnext == NULL) // 删除的是最后一个结点
{
p2-Pnext = NULL;
}
else // 删除中间的结点
{
p2-Pnext = p1-Pnext;
p1-Pnext = NULL;
}
printf("delete: %d\n",num);
n = n-1; // 链表长度 - 1
}
else
{
printf("%d not been found! \n",num);
}
delete(p1);
return(head);
}
/*******************************************************************
Author/data: /2009/09/16
Description: 添加一个结点到链表中
参数: head 为第一个结点的地址指针
stud 为要插入的结点的地址指针
*********************************************************************/
struct student *insert(struct student *head,struct student *stud)
{
struct student *p0,*p1,*p2;
p0 = stud;
p1 = head;
while(p0-nump1-num p1-Pnext!=NULL) // 找到添加结点的位置
{
p2 = p1; // p2 存放要添加的前一个结点的地址
p1 = p1-Pnext; // p1 存放要添加的后一个结点的地址
}
if(p0-num=p1-num p1-Pnext!=NULL)
{
if(p1 == head) // 添加结点到第一个位置
{
p0-Pnext = p1;
head = p0;
}
else
{
p2-Pnext = p0;
p0-Pnext = p1;
}
}
else // 添加结点到最后一个位置
{
p1-Pnext = p0;
p0-Pnext = NULL;
}
n = n+1; // 结点数目 + 1
return(head);
}
/*******************************************************************
Author/data: /2009/09/16
Description: 链表的重新排序===按照.num（不能重复）的大小从小到大排
列链表数据
参数: head 接收链表第一个节点的地址指针
返回值为新生成链表的第一个节点的地址指针
*********************************************************************/
struct student *linkpaix(struct student *head)
{
struct student *stemp,*ltemp,*shead,*head_h; /* */
struct student *p,*q; /* 申请两个链表指针，用来储存链表交换过
程的中间值 */
head_h = head;
ltemp = head;
p = (struct student *) malloc(LEN);
q = (struct student *) malloc(LEN); /* 为p，q开辟动态存储空间 */
/* -==== 先将链表的第一个数据与其他数据比较 ====- */
while(head-Pnext != NULL)
{
shead = head;
head = head-Pnext;
if(ltemp-num head-num)
{
if(ltemp == shead)
{
ltemp -Pnext = head -Pnext;
head -Pnext = ltemp;
}
else
{
p-Pnext = head -Pnext;
q-Pnext = ltemp -Pnext;
head -Pnext = q-Pnext;
shead -Pnext = ltemp;
ltemp -Pnext = p-Pnext;
}
head_h = head;
head = ltemp;
ltemp = head_h;
}
}
/* -==== 先将链表的第一个数据与其他数据比较 ====- */
/* -==== 比较链表第一个以外的数据 ====- */
while(ltemp -Pnext != NULL)
{
stemp = ltemp;
ltemp = ltemp -Pnext;
head = ltemp;
while(head-Pnext != NULL)
{
shead = head;
head = head-Pnext;
if(ltemp-num head-num)
{
if(ltemp == shead)
{
p-Pnext = head -Pnext;
stemp -Pnext = head;
head -Pnext = ltemp;
ltemp -Pnext = p-Pnext;
}
else
{
p-Pnext = head -Pnext;
q-Pnext = ltemp -Pnext;
stemp -Pnext = head;
head -Pnext = q-Pnext;
shead -Pnext = ltemp;
ltemp -Pnext = p-Pnext;
}
head = ltemp;
ltemp = stemp -Pnext;
}
}
}
/* -==== 比较链表第一个以外的数据 ====- */
free(p);
free(q); // 释放p，q的动态存储空间
return(head_h);
}
/*******************************************************************
Author/data: /2009/09/15
Description: 主函数
参数:
*********************************************************************/
void main()
{
struct student *phead,*pins; // 定义2个链表指针
int delnum, selflog,flog_a = 1,Nf = 1; // 要删除的对象id
char delflog ; // 删除标志y/n
char insflog, flog_nx = 'n';
char flog_free ; // 释放标志
/* === 输入N个数据 === N 为定值
printf("please input %d numbers:\n",N);
phead = pa(N); // 创建一个动态链表，并赋值
print(phead); // 输出链表数据
*/
/* === 输入Nx个数据 === Nx 为输入值 === */
int Nx; // Nx 想要输入的链表长度
printf("How long do you want establish? \t");
fflush(stdin);
scanf("%d",Nx);
/* -== 判断创建的是否是一个空链表 ==- */
while(Nx == 0)
{
printf("您要创建的是一个空链表，是否确定？y/n \t");
fflush(stdin);
scanf("%c",flog_nx);
if(flog_nx == 'n')
{
printf("How long do you want input?\t");
fflush(stdin);
scanf("%d",Nx);
}
else if(flog_nx == 'y') goto endl;
else
{
printf("wrong input!\n");
printf("How long do you want input?\t");
fflush(stdin);
scanf("%d",Nx);
}
}
printf("please input %d numbers: ",Nx);
printf("如:1,3 两个数中间以,隔开\n");
phead = pa(Nx); // 创建一个动态链表，并赋值
print(phead); // 输出链表数据
/* -== 链表操作 ==- */
while(flog_a)
{
if(phead == NULL) {printf("链表已空,无法操作\n"); flog_a = 0; break;}
printf("\n操作\n1:\t插入数据\n2:\t删除数据\n3:\t排序\n4:\t清屏\n5:\t输出现在的链表数据\n0:\texit\n");
printf("\nPlease input:\t");
fflush(stdin);
if(scanf("%d",selflog)) // select flog 选择项
switch(selflog)
{
case 1 :
/* ====== 插入数据到链表 ====== */
printf("insert someone? y/n\t");
fflush(stdin);
scanf("%c",insflog);
while(insflog != 'n')
{
while(insflog != 'y' insflog != 'n')
{
printf("wrnong input,please input again. \n");
printf("another one? y/n\t");
fflush(stdin);
scanf("%c",insflog);
}
printf("please input the date:\n");
pins = (struct student *)malloc(LEN);
fflush(stdin);
scanf("%d,%f",pins-num,pins-cj);
phead = insert(phead,pins);
print(phead);
printf("another one? y/n\t");
fflush(stdin);
scanf("%c",insflog);
while(insflog != 'y' insflog != 'n')
{
printf("wrnong input,please input again. \n");
printf("another one? y/n\t");
fflush(stdin);
scanf("%c",insflog);
}
}
/* ====== 插入数据到链表 ====== */
break;
case 2 :
/* ====== 删除链表中的数据 ====== */
printf("del someone? y/n\t");
fflush(stdin);
scanf("%c",delflog);
while(delflog != 'n' phead != NULL)
{
while(delflog != 'y' delflog != 'n')
{
printf("wrnong input,please input again. \n");
printf("del someone? y/n\t");
fflush(stdin);
scanf("%c",delflog);
}
printf("please input the student what you want del:\n");
fflush(stdin);
scanf("%d",delnum);
phead = del(phead,delnum);
print(phead);
printf("another one? y/n\t");
fflush(stdin);
scanf("%c",delflog);
if((n+1)==0)
{
printf("There is no more num could be del!\n");
break;
}
}
/* ====== 删除链表中的数据 ====== */
break;
case 3 :
/* ====== 排列链表数据 ====== */
printf("\n排序之后：");
phead = linkpaix(phead);
print(phead); // 排序该数据链表
/* ====== 排列链表数据 ====== */
break;
case 4 :// clrscr();
system("cls");
break;
case 5 : print(phead); break;
case 0 : flog_a = 0 ; break; /* 退出 */
default : printf("wrong input\nPlease input again");
break;
}
else printf("非法输入!\n");
}
endl: while(1)
{
if(Nx == 0)
{
printf("Can't establish the link!\n");
break;
}
printf("\n保留数据？y/n\t"); // 是否释放地址空间
fflush(stdin);
scanf("%c",flog_free);
if(flog_free == 'y')
{
break;
}
else if(flog_free == 'n')
{
freelinkspace(phead);
break;
}
else
{
printf("wrong input!\n");
}
}
printf("OVER!\nGOOD LUCK!\n");
}
C#中怎么复制数组
C#中数组复制有多种方法
数组间的复制，int[] pins = {9,3,4,9};int [] alias = pins;这里出了错误，也是错误的根源，以上代码并没有出错，但是根本不是复制，因为pins和alias都是引用，存在于堆栈中，而数据9,3,4,3是一个int对象存在于堆中，int [] alias = pins;只不过是创建另一个引用，alias和pins同时指向{9，3，4，3}，当修改其中一个引用的时候，势必影响另一个。复制的意思是新建一个和被复制对象一样的对象，在C#语言中应该有如下4种方法来复制。
方法一：使用for循环
int []pins = {9,3,7,2}
int []copy = new int[pins.length];
for(int i =0;i!=copy.length;i++)
{
copy[i] = pins[i];
}
方法二：使用数组对象中的CopyTo（）方法
int []pins = {9,3,7,2}
int []copy2 = new int[pins.length];
pins.CopyTo(copy2,0);
方法三：使用Array类的一个静态方法Copy()
int []pins = {9,3,7,2}
int []copy3 = new int[pins.length];
Array.Copy(pins,copy3,copy.Length);
方法四：使用Array类中的一个实例方法Clone（），可以一次调用，最方便，但是Clone（）方法返回的是一个对象，所以要强制转换成恰当的类类型。
int []pins = {9,3,7,2}
int []copy4 = (int [])pins.Clone();
方法五：
string[] student1 = { "$", "$", "c", "m", "d", "1", "2", "3", "1", "2", "3" };
string[] student2 = { "0", "1", "2", "3", "4", "5", "6", "6", "1", "8", "16","10","45", "37", "82" };
ArrayList student = new ArrayList();
foreach (string s1 in student1)
{
student.Add(s1);
}
foreach (string s2 in student2)
{
student.Add(s2);
}
string[] copyAfter = (string[])student.ToArray(typeof(string));
两个数组合并,最后把合并后的结果赋给copyAfter数组，这个例子可以灵活变通，很多地方可以用。
在C#中,采用什么属性表示数组的维数
C#声明数组时，方括号[]必须跟在类型后面，而不是标识符后面
1. 声明一维数组
C#数组的大小不是其类型的一部分，而在C语言中却是数组类型的一部分
int[] mySigArray = new int[4]; //声明数组类型，并使用new关键字为他分配内存空间/*上述声明可分解为以下两步*/int[] mySigArray; //声明数组类型mySigArray = new int[4]; //使用new关键字为他分配内存空间
另外C#声明数组时支持分配内存的方括号内是整型变量或变量表达式，只要事先确定了变量的值即可(这个在C语言的C99标准出现之前是不允许的)
int[] mySigArray = new int[n]; //n的值必须事先确定，声明之后即使改变n的值数组大小也不会变
2. 声明多维数组
int[,] myMulArray = new int[4,3]; //声明二维整型数组
3. 声明锯齿数组(数组的数组)
多维数组的大小是矩形的，例如3X3（也可以是是4×3，只需每行大小相同）个元素。而锯齿数组的大小设置比较灵活，在锯齿数组中，每一行都可以有不同的大小，如下图，锯齿数组成锯齿状
int[][] mySawArray = new int[3][]; //注意与二维数组不同，这里有两个方括号
数组的初始化
如果有初始化数据，可以用以下最简单的形式初始化
int[] mySigArray = {1,2,3,4}; //一维数组初始化int[,] myMulArray = {{1,2,3},{4,5,6},{7,8,9}}; //二维数组初始化int[][] mySawArray = {new int[] {1,2},new int[] {3,4,5,6,7,8},new int[] {9,10,11}}; //锯齿数组初始化
数组的访问
1. 访问上述初始化的的数组中单个元素
int i = mySigArray[2]; //i=3int j = myMulArray[2,1]; //j=8int k = mySawArray[2][1]; //k=10注意二维数组与锯齿数组的区别
2. 遍历访问数组元素
C#提供了foreach语句，该语句提供了一种简单、明了的方法来循环访问数组
foreach(int m in myArray) //将所有数组元素的值加1，myArray可以是一维、多维或锯齿数组{
m++;
}
另外也可以用for循环遍历数组，使用这种方式可以更好的控制数组元素(知道每次循环中的数组对象是哪个)，下面这段代码用foreach语句是无法实现的
for (int i = 0; i mySawArray.Length; i++)
{ for (int j = 0; j mySawArray[i].Length; j++)
{
myMulArray[i,j]=mySawArray[i][j]; //把锯齿数组的每个元素赋值给二维数组中相应的元素 }
}
数组的常用属性和方法
在C#中，数组实际上是对象。System.Array是所有数组类型的抽象基类型，提供创建、操作、搜索和排序数组的方法，因此所有的数组都可以使用它的属性和方法
1. 常用属性
Length:获得一个32位整数，该整数表示Array的所有维数中元素的总数，即数组的元素个数，常用来限制数组下标的大小
2. 常用方法
2.1 数组的复制
在C#中，数组的复制一般分为以下三种：
int[] pins = {3,9,7,2};int[] copy1 = new int[pins.Length];pins.CopyTo(copy1,0); //使用数组对象的CopyTo()方法进行复制,参数0表示从copy1数组的第一个元素(下标是0)开始放置从pins数组复制过来的值int[] copy2 = new int[pins.Length];Array.Copy(pins,copy2,copy2.Length); //使用Array类的一个静态方法Copy(),参数copy2.Length表示从pins数组的第一个元素开始到copy2数组所能容纳的最后一个元素(copy2.Length)都复制到copy2数组int[] copy3 = (int[])pins.Clone(); //使用数组对象的Clone()方法,它会创建一个新的数组，返回值是一个对象，所以需要强制类型转换成恰当的类型
2.2 数组的排序
排序是编程中常用的算法之一。C#中提供了两个数组排序的方法：
Array.Sort(Array)用于对数组进行从小到大排序
Array.Reverse(Array)用于对数组进行反向排序
int[] pins = {3,9,7,2};
Array.Sort(pins); //pins={2,3,7,9}Array.Reverse(pins); //pins={9,7,3,2}
怎样用C语言做一个按钮并设置点击反应
void delay() //延迟子程序
{
unsigned char i,j;
i=5;
while(i--)
for(j=0;j200;j++);
}
uint key() //按键子程序
{
f(k1==0)// 当按键按下时
{
delay( );// 延迟等待
if(k1==0) // 如果按键还是按下的动作，确定按键已经按下
while(!k1) ; // 当按键有弹起以后，再执行动作
{ /*这里自己/设置按键按下以后要执行的动作*/}
}
}
希望对您有所帮助！
