C语言

11、判断某一年是否是闰年。

[cpp] view plain copy print?
//判断某一年份是否是闰年
int IsLeapYear(int year)
{
return (year % 400 == 0 || (year % 4 == 0) && (year % 100 != 0));
}

运行结果:

12、获得某年、某月的最大天数。

[cpp] view plain copy print?
//获得某年、某月的最大天数
int GetMaxDay(int year,int month)
{
switch(month)
{
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
return 31;
case 4:
case 6:
case 9:
case 11:
return 30;
case 2:
return IsLeapYear(year)?29:28;
default:return -1;
}
}

运行结果:

13、输入某年某月某日,判断这一天是这一年的第几天?

[cpp] view plain copy print?
//输入某年某月某日,判断这一天是这一年的第几天?
/*
程序分析:以3月5日为例,应该先把前两个月的加起来,然后再加上5天即本年的第几天,特殊
情况,闰年且输入月份大于3时需考虑多加一天。
*/
int GetDays(int year,int month,int day)
{
int sum = 0;
int i;
for(i = 1; i < month; i++) //将前几个月天数相加
sum += GetMaxDay(year,month);
sum = sum + day; //加上本月的天数,就是总天数
return sum;
}

运行结果:

更多关于日期的算法,请参见我的博客《关于日期的常用算方法》(java版)。

14、求一个数的阶乘。

[cpp] view plain copy print?
//递归求阶乘
long factorial(long n)
{
if(n <= 1)
return 1;
else
return n * factorial(n-1);
}
//非递归求阶乘
long Factorial(long n)
{
int sum,i;
sum = 1;
for(i = 1; i <= n; i++)
sum *= i;
return sum;
}

运行结果:

这里求得的阶乘只能是较小数的阶乘,想求得200或更大数的阶乘就无能无力了,所以必须通过其他的算法来实现。

15、求两个数的最大公约数和最小公倍数。

[cpp] view plain copy print?
//求两个数的最大公约数
int gcd(int a,int b)
{
int r;
if(a < b) //a < b,则交换两个数
{
int temp = a;
a = b;
b = temp;
}

r = a % b;
while(r != 0)
{
a = b;
b = r;
r = a % b;
}
return b;
}
//求两个数的最小公倍数数
int lcm(int a,int b)
{
return a*b/gcd(a,b);
}

运行结果:

16、打印出三位的"水仙花数",所谓"水仙花数"是指一个N位数,其各位数字立方和等于该数。

[cpp] view plain copy print?
//打印出三位的"水仙花数",所谓"水仙花数"是指一个N位数,其各位数字立方和等于该数
void WaterFlowerNumber()
{
int i,j,k,n;
printf("Water flower number is:");
for(n = 100; n < 1000; n++)
{
i = n/100; //分解百位
j = n/10 % 10; //分解十位
k = n % 10; //分解个位
if(i*i*i + j*j*j + k*k*k == n)
printf("%-5d\n",n);
}
}

运行结果:

大家还可以考虑一下,如何打印21位“水仙花”数? (基本思想和《大数阶乘的实现》及《求任意位数的Pi》的思想相同,即用数组存储)。

17、不依赖第三个变量,实现两个整数交换。

[cpp] view plain copy print?
/不依赖第三个变量,实现两个整数交换
//第一种方法
void Exchange1(int* a,int* b)
{
*a = *a + *b;
*b = *a - *b;
*a = *a - *b;
}
//第二种方法(用位运算)
void Exchange2(int* a,int* b)
{
*a = *a ^ *b;
*b = *a ^ *b;
*a = *a ^ *b;
}

运行结果:

18、将10进制的数转换为2-16进制。

[cpp] view plain copy print?
//将10进制数转换为其它进制
void From10baseTransformTo1_16(int m,int base)
{
char num[] = "0123456789ABCDEF";
char result[30] = {0};
int len = 0;
char temp;
int start = 0;
int end = len;

while(m) //辗转相除,先存正向的余数
{
result[len++] = num[m%base];
m = m / base;
}

start = 0;
end = len-1;
while(start < end) //字符串翻转
{
temp = result[start];
result[start] = result[end];
result[end] = temp;
start++;
end--;
}

start = 0;
for(start = 0; start < len; start++)
printf("%c",result[start]);
printf("\n");

}

运行结果:

19、将一个正整数分解质因数。例如:输入90,打印出90=2*3*3*5。

[cpp] view plain copy print?
//将一个正整数分解质因数。例如:输入90,打印出90=2*3*3*5。
void DivideFactor(int n)
{
int i;
printf("\nplease input a number:\n");
scanf("%d",&n);
printf("%d=",n);

for(i=2;i<=n;i++)
{
while(n!=i)
{
if(n%i==0)
{
printf("%d*",i);
n=n/i;
}
else
{
break;
}
}
}
printf("%d",n);

}

运行结果:

20、猴子吃桃问题:

猴子第一天摘下若干个桃子,当即吃了一半,还不瘾,又多吃了一个第二天早上又将剩下的桃子吃掉一半,又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时,见只剩下一个桃子了。求第一天共摘了多少。

程序分析:采取逆向思维的方法,从后往前推断。

[cpp] view plain copy print?
void MonkeyEatPeach()
{
int day,x1,x2;
day=9;
x2=1;
while(day>0)
 {x1=(x2+1)*2;/*第一天的桃子数是第2天桃子数加1后的2倍*/
 x2=x1;
 day--;
 }
printf("the total is %d\n",x1);
}

运行结果:

文章来源:牟尼的博客

围观 351

C语言中有有许多经典的算法,这些算法都是许多人的智慧结晶,也是编程中常用的算法,这里面包含了众多算法思想,掌握这些算法,对于学习更高级的、更难的算法都会有很大的帮助,会为自己的算法学习打下坚实的基础。

接下来我们先来看10道:

(1)输出9*9乘法口诀。

[cpp] view plain copy print?
//9*9乘法口诀表
void Table99()
{
int i,j;
for(i = 1; i <= 9; i++) //外层循环控制行
{
for(j = 1; j <= i; j++) //内层循环控制列
{
printf("%d*%d=%-4d",i,j,i*j);
}
printf("\n");
}
}

运行结果:

(2)古典问题:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少?(兔子的规律为数列1,1,2,3,5,8,13,21....)这也是著名的斐波那契数列。

[cpp] view plain copy print?
//斐波那契数列
void Fabocci()
{
long int f1,f2;
f1 = f2 = 1;
int i;
for(i = 1; i <= 20; i++)
{
printf("%12ld %12ld ",f1,f2);
if(i % 2 == 0) //控制输出,每行输出4个
printf("\n");
f1 = f1+f2; //后一个数是前两个数的和
f2 = f1+f2; //后一个数是前两个数的和
}

}

运行结果:

(3)1-100之间有多少个素数,并输出所有素数及素数的个数。

程序分析:判断素数的方法:用一个数分别去除2到sqrt(这个数),如果能被整除,则表明此数不是素数,反之是素数。

[cpp] view plain copy print?
//输出1-100的所有素数
void Prime()
{
int i,j,flag,n;
n = 100; //100以内的素数
flag = 1; //标识变量,是素数则为1

for(i = 2; i <= 100; i++) //从2开始,遍历到100
{
flag = 1;
for(j = 2; j*j <= i; j++) //能被2 - sqrt(i)整除的数
{
if(i % j == 0)
{
flag = 0;
break;
}
}
if(flag == 1)
printf("%d ",i); //输出素数
}
}

关于一个数是否是素数,还有更高效的算法,大家可以先考虑一下,以后我会给出算法。

运行结果:

(4)一个数如果恰好等于它的因子之和,这个数就称为“完数”。例如6 = 1+2+3,找出10000以内的所有完数。

[cpp] view plain copy print?
//找出1000以内的所有完数(一个数等于其因子之和)
void PerfectNumber()
{
int p[80]; //保存分解的因子
int i,num,count,s,c = 0;
int MaxNum = 10000;

for(num = 2; num < MaxNum; num++)
{
count = 0;
s = num;
for(i = 1; i < num/2+1; i++) //循环处理每个数
{
if(num % i == 0) //能被i整除
{
p[count++] = i; //保存因子,让计数器count增加1
s -= i; //减去一个因子
}
}
if( 0 == s)
{
printf("%4d是一个完数,因子是:",num);
printf("%d = %d",num,p[0]); //输出完数
for(i = 1; i < count; i++)
printf("+%d",p[i]);
printf("\n");
c++;
}
}
printf("\n共找到%d个完数。\n",c);
}

运行结果:

(5)下面程序的功能是将一个4×4的数组进行逆时针旋转90度后输出,要求原始数组的数据随机输入,新数组以4行4列的方式输出。

[cpp] view plain copy print?
void Array4_4()
{
int A[4][4],B[4][4],i,j;

printf("Please Input 16 numbers:");
for(i = 0; i < 4; i++)
for(j = 0; j < 4; j++)
{
scanf("%d",&A[i][j]); //输入16个数
B[3-j][i] = A[i][j]; //旋转90度赋值
}
printf("Array A:\n"); //输出矩阵A
for( i = 0; i < 4; i++)
{
for(j = 0 ; j < 4; j++)
{
printf("%4d",A[i][j]);
}
printf("\n");
}
printf("Array B:\n"); //输出矩阵B
for( i = 0; i < 4; i++)
{
for(j = 0 ; j < 4; j++)
{
printf("%4d",B[i][j]);
}
printf("\n");
}
}

运行结果:

(6)编程打印杨辉三角。

[cpp] view plain copy print?
//打印杨辉三角
void YangHuiTriangle()
{
int i,j,triangle[8][8];

for(i = 0; i < 8; i++)
for(j = 0; j < 8; j++)
triangle[i][j] = 1;

for(i = 2; i < 8; i++)
{
for(j = 1; j < i; j++)
{
triangle[i][j] = triangle[i-1][j]+triangle[i-1][j-1];
}
}
for(i = 0; i < 8; i++)
{
for(j = 0; j <= i; j++)
printf("%-4d",triangle[i][j]);
printf("\n");
}

}

运行结果:

(7)实现将输入的字符串反序输出。

[cpp] view plain copy print?
/*实现字符串翻转*/
char* reverse_str(char* str)
{
if(NULL == str) //字符串为空直接返回
{
return str;
}
char *begin;
char *end;
begin = end = str;

while(*end != '\0') //end指向字符串的末尾
{
end++;
}
--end;

char temp;
while(begin < end) //交换两个字符
{
temp = *begin;
*begin = *end;
*end = temp;
begin++;
end--;
}

return str; //返回结果
}

运行结果:

(8)实现字符串拷贝函数strcopy(char*src,char* dest)

[cpp] view plain copy print?
void strcopy(char *str, char *dest)
{
while(*str != '\0')
{
*dest++ = *str++;
}
*dest = '\0';
}

(9)求近似Pi值。可以用公式(如:pi/2 = 1+1/3+1/3*2/5 + 1/3*2/5*3/7 + 1/3*2/5*3/7*4/9+.....)

[cpp] view plain copy print?
void Pi()
{
double pi = 2,temp = 2; //初始化pi值和临时值
int numerator = 1,denominator = 3; //初始化分子和分母

while(temp > 1e-16) //数列大于指定精度
{
temp = temp*numerator/denominator;//计算一个数列的值
pi += temp;
numerator++;
denominator += 2;
}
printf("PI = %.18f\n",pi);
}

这里求得的只是近似的值,精度不高,对于求任意位的pi值就无能无力了,大家可以考虑如何求任意位数的pi值,

关于任意位数的pi值求法,可以参见我的博客:《计算任意位数的Pi》

运行结果:

(10)输入一个字符串,判断其是否为回文。回文字符串是指从左到右读和从右到左读完全相同的字符串。

[cpp] view plain copy print?
//判断一个字符串是否是回文
void IsHuiWen()
{
char str[100];
int i,j,n;
printf("请输入一段字符串:");
gets(str);
n = strlen(str);
for(i = 0,j = n-1; i < j; i++,j--)
if(str[i] != str[j])
break;
if(i >= j)
printf("是回文!\n");
else
printf("不是回文!\n");

}

运行结果:

文章来源:牟尼的博客

围观 268

在计机领域,堆栈是一个不容忽视的概念,我们编写的C语言程序基本上都要用到。但对于很多的初学着来说,堆栈是一个很模糊的概念。堆栈:一种数据结构、一个在程序运行时用于存放的地方,这可能是很多初学者的认识,因为我曾经就是这么想的和汇编语言中的堆栈一词混为一谈。我身边的一些编程的朋友以及在网上看帖遇到的朋友中有好多也说不清堆栈,所以我想有必要给大家分享一下我对堆栈的看法,有说的不对的地方请朋友们不吝赐教,这对于大家学习会有很大帮助。

首先了解下计算机C语言中各个变量的存放区域:
代码区(CODE): 存放函数代码;
静态数据区(DATA): 存放全局变理/静态变量;
堆区(HEAP): 是自由存储区,存放动态数据,像new,malloc()申请的空间就是堆区的;
栈区(STACK): 存放临时/局部变量。

数据结构的栈和堆
首先在数据结构上要知道堆栈,尽管我们这么称呼它,但实际上堆栈是两种数据结构:堆和栈。
堆和栈都是一种数据项按序排列的数据结构。

栈就像装数据的桶或箱子
我们先从大家比较熟悉的栈说起吧,它是一种具有 后进先出 性质的数据结构,也就是说后存放的先取,先存放的后取。这就如同我们要取出放在箱子里面底下的东西(放入的比较早的物体),我们首先要移开压在它上面的物体(放入的比较晚的物体)。

堆像一棵倒过来的树
而堆就不同了,堆是一种 经过排序的树形数据结构 ,每个结点都有一个值。通常我们所说的堆的数据结构,是指二叉堆。堆的特点是根结点的值最小(或最大),且根结点的两个子树也是一个堆。由于堆的这个特性,常用来实现优先队列, 堆的存取是随意 ,这就如同我们在图书馆的书架上取书,虽然书的摆放是有顺序的,但是我们想取任意一本时不必像栈一样,先取出前面所有的书,书架这种机制不同于箱子,我们可以直接取出我们想要的书。

内存分配中的栈和堆
然而我要说的重点并不在这,我要说的堆和栈并不是数据结构的堆和栈,之所以要说数据结构的堆和栈是为了和后面我要说的堆区和栈区区别开来,请大家一定要注意。
下面就说说C语言程序内存分配中的堆和栈,这里有必要把内存分配也提一下,大家不要嫌我啰嗦,一般情况下程序存放在Rom或Flash中,运行时需要拷到内存中执行,内存会分别存储不同的信息,如下图所示:

内存中的栈区处于相对较高的地址以地址的增长方向为上的话,栈地址是向下增长的。
栈中分配局部变量空间,堆区是向上增长的用于分配程序员申请的内存空间。另外还有静态区是分配静态变量,全局变量空间的;只读区是分配常量和程序代码空间的;以及其他一些分区。

来看一个网上很流行的经典例子:
main.cpp
int a = 0; 全局初始化区
char *p1; 全局未初始化区
main()
{
int b; 栈
char s[] = "abc"; 栈
char *p2; 栈
char *p3 = "123456"; 123456\0在常量区,p3在栈上。
static int c =0; 全局(静态)初始化区
p1 = (char *)malloc(10); 堆
p2 = (char *)malloc(20); 堆
}

0.申请方式和回收方式不同
不知道你是否有点明白了,堆和栈的第一个区别就是申请方式不同:栈(英文名称是stack)是系统自动分配空间的,例如我们定义一个 char a; 系统会自动在栈上为其开辟空间 。而堆(英文名称是heap)则是 程序员根据需要自己申请的空间 ,例如malloc(10);开辟十个字节的空间。由于 栈上的空间是自动分配自动回收的 ,所以栈上的数据的生存周期只是在函数的运行过程中,运行后就释放掉,不可以再访问。而 堆上的数据只要程序员不释放空间,就一直可以访问到 ,不过缺点是一旦忘记释放会造成内存泄露。还有其他的一些区别我认为网上的朋友总结的不错这里转述一下:

1.申请后系统的响应
栈:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。

堆:首先应该知道 操作系统有一个记录空闲内存地址的链表 ,当系统收到程序的申请时,会遍历该链表,寻找第一个空间大于所申请空间的堆。

结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序,另外,对于大多数系统,会在这块内存空间中的 首地址处记录本次分配的大小 ,这样,代码中的 delete语句才能正确的释放本内存空间。另外,由于找到的堆结点的大小不一定正好等于申请的大小,系统会自动的 将多余的那部分重新放入空闲链表中 。

也就是说 堆会在申请后还要做一些后续的工作这就会引出申请效率的问题。

2.申请效率的比较
根据第0点和第1点可知。
栈:由系统自动分配,速度较快。但程序员是无法控制的。

堆:是由new分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便。

3.申请大小的限制
栈:在Windows下,栈是向低地址扩展的数据结构,是一块 连续的内存的区域 。这句话的意思是 栈顶的地址和栈的最大容量是系统预先规定好的 ,在 WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。

堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。

4.堆和栈中的存储内容
由于栈的大小有限,所以用子函数还是有物理意义的,而不仅仅是逻辑意义。

栈:在函数调用时,第一个进栈的是 主函数中函数调用后的下一条指令 (函数调用语句的下一条可执行语句)的地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是 函数中的局部变量 。注意静态变量是不入栈的。

当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是主函数中的下一条指令,程序由该点继续运行。

堆 :一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

关于存储内容还可以参考 这道题 。这道题还涉及到局部变量的存活期。

5.存取效率的比较
char s1[] = "aaaaaaaaaaaaaaa";
char *s2 = "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在运行时刻赋值的;放在栈中。

但是,在以后的存取中,在栈上的数组比指针所指向的字符串(例如堆)快。

比如:
#include
void main()
{
char a = 1;
char c[] = "1234567890";
char *p ="1234567890";
a = c[1];
a = p[1];
return;
}
对应的汇编代码
10: a = c[1];
00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]
0040106A 88 4D FC mov byte ptr [ebp-4],cl
11: a = p[1];
0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]
00401070 8A 42 01 mov al,byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4],al

关于堆和栈区别的比喻
堆和栈的区别可以引用一位前辈的比喻来看出:
使用栈就象我们去饭馆里吃饭,只管点菜(发出申请)、付钱、和吃(使用),吃饱了就走,不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作,他的好处是快捷,但是自由度小。

使用堆就象是自己动手做喜欢吃的菜肴,比较麻烦,但是比较符合自己的口味,而且自由度大。比喻很形象,说的很通俗易懂,不知道你是否有点收获。

来源:极客头条

围观 344

1、static关键字

这个关键字前面也有提到,它的作用是强大的。

要对static关键字深入了解,首先需要掌握标准C程序的组成。

标准C程序一直由下列部分组成:

1)正文段——CPU执行的机器指令部分,也就是你的程序。一个程序只有一个副本;只读,这是为了防止程序由于意外事故而修改自身指令;

2)初始化数据段(数据段)——在程序中所有赋了初值的全局变量,存放在这里。

3)非初始化数据段(bss段)——在程序中没有初始化的全局变量;内核将此段初始化为0。

注意:只有全局变量被分配到数据段中。

4)栈——增长方向:自顶向下增长;自动变量以及每次函数调用时所需要保存的信息(返回地址;环境信息)。这句很关键,常常有笔试题会问到什么东西放到栈里面就足以说明。

5)堆——动态存储分配。

在嵌入式C语言当中,它有三个作用:

作用一:在函数体,一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

这样定义的变量称为局部静态变量:在局部变量之前加上关键字static,局部变量就被定义成为一个局部静态变量。也就是上面的作用一中提到的在函数体内定义的变量。除了类型符外,若不加其它关键字修饰,默认都是局部变量。比如以下代码:

void test1(void)

{

unsigned char a;

static unsigned char b;

a++;

b++;

}

在这个例子中,变量a是局部变量,变量b为局部静态变量。作用一说明了局部静态变量b的特性:在函数体,一个被声明为静态的变量(也就是局部静态变量)在这一函数被调用过程中维持其值不变。这句话什么意思呢?若是连续两次调用上面的函数test1:

void main(void)

{

test1();

test1();

}

然后使程序暂停下来,读取a和b的值,你会发现,a=1,b=2。怎么回事呢,每次调用test1函数,局部变量a都会重新初始化为0x00;然后执行a++;而局部静态变量在调用过程中却能维持其值不变。

通常利用这个特性可以统计一个函数被调用的次数。

声明函数的一个局部变量,并设为static类型,作为一个计数器,这样函数每次被调用的时候就可以进行计数。这是统计函数被调用次数的最好的办法,因为这个变量是和函数息息相关的,而函数可能在多个不同的地方被调用,所以从调用者的角度来统计比较困难。代码如下:

void count();
int main()
{
int i;
for (i = 1; i <= 3; i++)

{
count();

{
return 0;
}
void count()
{
static num = 0;
num++;
printf(" I have been called %d",num,"times/n");
}

输出结果为:

I have been called 1 times.
I have been called 2 times.
I have been called 3 times.

看一下局部静态变量的详细特性,注意它的作用域。

1)内存中的位置:静态存储区

2)初始化:未经初始化的全局静态变量会被程序自动初始化为0(自动对象的值是任意的,除非他被显示初始化)

3)作用域:作用域仍为局部作用域,当定义它的函数或者语句块结束的时候,作用域随之结束。

注:当static用来修饰局部变量的时候,它就改变了局部变量的存储位置,从原来的栈中存放改为静态存储区。但是局部静态变量在离开作用域之后,并没有被销毁,而是仍然驻留在内存当中,直到程序结束,只不过我们不能再对他进行访问。

作用二:在模块内(但在函数体外),一个被声明为静态的变量可以被模块内所用函数访问,但不能被模块外其它函数访问。它是一个本地的全局变量。

这样定义的变量也称为全局静态变量:在全局变量之前加上关键字static,全局变量就被定义成为一个全局静态变量。也就是上述作用二中提到的在模块内(但在函数体外)声明的静态变量。

定义全局静态变量的好处:

<1>不会被其他文件所访问,修改,是一个本地的局部变量。

<2>其他文件中可以使用相同名字的变量,不会发生冲突。

全局变量的详细特性,注意作用域,可以和局部静态变量相比较:

1)内存中的位置:静态存储区(静态存储区在整个程序运行期间都存在)

2)初始化:未经初始化的全局静态变量会被程序自动初始化为0(自动对象的值是任意的,除非他被显示初始化)

3)作用域:全局静态变量在声明他的文件之外是不可见的。准确地讲从定义之处开始到文件结尾。

当static用来修饰全局变量的时候,它就改变了全局变量的作用域(在声明他的文件之外是不可见的),但是没有改变它的存放位置,还是在静态存储区中。

作用三:在模块内,一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是,这个函数被限制在声明它的模块的本地范围内使用。

这样定义的函数也成为静态函数:在函数的返回类型前加上关键字static,函数就被定义成为静态函数。函数的定义和声明默认情况下是extern的,但静态函数只是在声明他的文件当中可见,不能被其他文件所用。

定义静态函数的好处:

<1> 其他文件中可以定义相同名字的函数,不会发生冲突

<2> 静态函数不能被其他文件所用。它定义一个本地的函数。

这里我一直强调数据和函数的本地化,这对于程序的结构甚至优化都有巨大的好处,更大的作用是,本地化的数据和函数能给人传递很多有用的信息,能约束数据和函数的作用范围。在C++的对象和类中非常注重的私有和公共数据/函数其实就是本地和全局数据/函数的扩展,这也从侧面反应了本地化数据/函数的优势。

最后说一下存储说明符,在标准C语言中,存储说明符有以下几类:

auto、register、extern和static

对应两种存储期:自动存储期和静态存储期。

auto和register对应自动存储期。具有自动存储期的变量在进入声明该变量的程序块时被建立,它在该程序块活动时存在,退出该程序块时撤销。

关键字extern和static用来说明具有静态存储期的变量和函数。用static声明的局部变量具有静态存储持续期(static storage duration),或静态范围(static extent)。虽然他的值在函数调用之间保持有效,但是其名字的可视性仍限制在其局部域内。静态局部对象在程序执行到该对象的声明处时被首次初始化。

2、const 关键字

const关键字也是一个优秀程序中经常用到的关键字。关键字const 的作用是为给读你代码的人传达非常有用的信息,实际上,声明一个参数为常量是为了告诉了用户这个参数的应用目的。通过给优化器一些附加的信息,使用关键字const 也许能产生更紧凑的代码。合理地使用关键字const 可以使编译器很自然地保护那些不希望被改变的参数,防止其被无意的代码修改。简而言之,这样可以减少bug的出现。

深入理解const关键字,你必须知道:

a. const关键字修饰的变量可以认为有只读属性,但它绝不与常量划等号。如下代码:

const int i=5;

int j=0;

...

i=j; //非法,导致编译错误,因为只能被读

j=i; //合法

b. const关键字修饰的变量在声明时必须进行初始化。如下代码:

const int i=5; //合法

const int j; //非法,导致编译错误

c. 用const声明的变量虽然增加了分配空间,但是可以保证类型安全。const最初是从C++变化得来的,它可以替代define来定义常量。在旧版本(标准前)的c中,如果想建立一个常量,必须使用预处理器:

#define PI 3.14159

此后无论在何处使用PI,都会被预处理器以3.14159替代。编译器不对PI进行类型检查,也就是说可以不受限制的建立宏并用它来替代值,如果使用不慎,很可能由预处理引入错误,这些错误往往很难发现。而且,我们也不能得到PI的地址(即不能向PI传递指针和引用)。const的出现,比较好的解决了上述问题。

d. C标准中,const定义的常量是全局的。

e. 必须明白下面语句的含义,我自己是反复记忆了许久才记住,方法是:若是想定义一个只读属性的指针,那么关键字const要放到‘* ’后面。

char *const cp; //指针不可改变,但指向的内容可以改变

char const *pc1; //指针可以改变,但指向的内容不能改变

const char *pc2; //同上(后两个声明是等同的)

f. 将函数传入参数声明为const,以指明使用这种参数仅仅是为了效率的原因,而不是想让调用函数能够修改对象的值。

参数const通常用于参数为指针或引用的情况,且只能修饰输入参数;若输入参数采用“值传递”方式,由于函数将自动产生临时变量用于复制该参数,该参数本就不需要保护,所以不用const修饰。例子:

void fun0(const int * a );

void fun1(const int & a);

调用函数的时候,用相应的变量初始化const常量,则在函数体中,按照const所修饰的部分进行常量化,如形参为const int * a,则不能对传递进来的指针所指向的内容进行改变,保护了原指针所指向的内容;如形参为const int & a,则不能对传递进来的引用对象进行改变,保护了原对象的属性。

g. 修饰函数返回值,可以阻止用户修改返回值。(在嵌入式C中一般不用,主要用于C++)

h. const消除了预处理器的值替代的不良影响,并且提供了良好的类型检查形式和安全性,在可能的地方尽可能的使用const对我们的编程有很大的帮助,前提是:你对const有了足够的理解。

最后,举两个常用的标准C库函数声明,它们都是使用const的典范。

(1)字符串拷贝函数:char *strcpy(char *strDest,const char *strSrc);

(2)返回字符串长度函数:int strlen(const char *str);

3、 volatile关键字

一个定义为volatile 的变量是说这变量可能会被意想不到地改变,这样,编译器就不会去假设这个变量的值了。精确地说就是,优化器在用到这个变量时必须每次都小心地重新读取这个变量的值,而不是使用保存在寄存器里的备份。

由于访问寄存器的速度要快过RAM,所以编译器一般都会作减少存取外部RAM的优化。比如:

static int i=0;

int main(void)
{
...
while (1)
{
if (i)
dosomething();
}
}

/* Interrupt service routine. */
void ISR_2(void)
{
i=1;
}

程序的本意是希望ISR_2中断产生时,在main当中调用dosomething函数,但是,由于编译器判断在main函数里面没有修改过i,因此可能只执行一次对从i到某寄存器的读操作,然后每次if判断都只使用这个寄存器里面的“i副本”,导致dosomething永远也不会被调用。

如果将将变量加上volatile修饰,则编译器保证对此变量的读写操作都不会被优化(肯定执行)。此例中i也应该如此说明。

一般说来,volatile用在如下的几个地方:

1、中断服务程序中修改的供其它程序检测的变量需要加volatile;

2、多任务环境下各任务间共享的标志应该加volatile;

3、存储器映射的硬件寄存器通常也要加volatile说明,因为每次对它的读写都可能有不同意义;

不懂得volatile 的内容将会带来灾难,这也是区分C语言和嵌入式C语言程序员的一个关键因素。为强调volatile的重要性,再次举例分析:

代码一:

int a,b,c;

//读取I/O空间0x100端口的内容

a= inword(0x100);

b=a;

a=inword(0x100)

c=a;

代码二:

volatile int a;

int a,b,c;

//读取I/O空间0x100端口的内容

a= inword(0x100);

b=a;

a=inword(0x100)

c=a;

在上述例子中,代码一会被绝大多数编译器优化为如下代码:

a=inword(0x100)

b=a;

c=a;

这显然与编写者的目的不相符,会出现I/O空间0x100端口漏读现象,若是增加volatile,像代码二所示的那样,优化器将不会优化掉任何代码.

从上面来看,volatile关键字是会降低编译器优化力度的,但它保证了程序的正确性,所以在适合的地方使用关键字volatile是件考验编程功底的事情.

4、struct与typedef关键字

面对一个人的大型C/C++程序时,只看其对struct的使用情况我们就可以对其编写者的编程经验进行评估。因为一个大型的C/C++程序,势必要涉及一些(甚至大量)进行数据组合的结构体,这些结构体可以将原本意义属于一个整体的数据组合在一起。从某种程度上来说,会不会用struct,怎样用struct是区别一个开发人员是否具备丰富开发经历的标志。

在网络协议、通信控制、嵌入式系统的C/C++编程中,我们经常要传送的不是简单的字节流(char型数组),而是多种数据组合起来的一个整体,其表现形式是一个结构体。

经验不足的开发人员往往将所有需要传送的内容依顺序保存在char型数组中,通过指针偏移的方法传送网络报文等信息。这样做编程复杂,易出错,而且一旦控制方式及通信协议有所变化,程序就要进行非常细致的修改。

用法:

在C中定义一个结构体类型要用typedef:
typedef struct Student
{
int a;
}Stu;
于是在声明变量的时候就可:Stu stu1;
如果没有typedef就必须用struct Student stu1;来声明
这里的Stu实际上就是struct Student的别名。
另外这里也可以不写Student(于是也不能struct Student stu1;了)
typedef struct
{
int a;
}Stu;

struct关键字的一个总要作用是它可以实现对数据的封装,有一点点类似与C++的对象,可以将一些分散的特性对象化,这在编写某些复杂程序时提供很大的方便性.

比如编写一个菜单程序,你要知道本级菜单的菜单索引号、焦点在屏上是第几项、显示第一项对应的菜单条目索引、菜单文本内容、子菜单索引、当前菜单执行的功能操作。若是对上述条目单独操作,那么程序的复杂程度将会大到不可想象,若是菜单层数少些还容易实现,一旦菜单层数超出四层,呃~我就没法形容了。若是有编写过菜单程序的朋友或许理解很深。这时候结构体struct就开始显现它的威力了:

//结构体定义

typedef struct

{

unsigned char CurrentPanel;//本级菜单的菜单索引号

unsigned char ItemStartDisplay; //显示第一项对应的菜单条目索引

unsigned char FocusLine; //焦点在屏上是第几项

}Menu_Statestruct;

typedef struct

{

unsigned char *MenuTxt; //菜单文本内容

unsigned char MenuChildID;//子菜单索引

void (*CurrentOperate)();//当前菜单执行的功能操作

}MenuItemStruct;

typedef struct

{

MenuItemStruct *MenuPanelItem;

unsigned char MenuItemCount;

}MenuPanelStruct;

这里引用我巩师兄所写的菜单程序中的结构体定义,这个菜单程序最大可以到256级菜单。我当初要写一个菜单程序之前,并没有对结构体了解多少,也没有想到使用结构体。只是一层层菜单的单独处理:如果按键按下,判断是哪个按键,调用对应按键的子程序,刷屏显示。这样处理起来每一层都要判断当前的光标所在行,计算是不是在显示屏的顶层,是不是在显示层的底层,是不是需要翻页等等,非常的繁琐。后来在网上找资料,就找到了我师兄编写的这个程序,开始并不知道是他写的,在看源程序的时候看到了作者署名:中国传惠 TranSmart,才知道是他。花了一天的时间阅读代码和移植,才知道结构体原来有这么个妙用,当定义了上述三个结构体之后,菜单程序结构立刻变的简单很多,思路也无比的清晰起来。

作者:襄坤在线

文章来源:博客园

围观 401

在嵌入式系统开发中,目前使用的主要编程语言是C 和汇编,虽然C++已经有相应的编译器,但是现在使用还是比较少的。

在稍大规模的嵌入式程序设计中,大部分的代码都是用C来编写的,主要是因为C语言具有较强的结构性,便于人的理解,并且具有大量的库支持。但对于一写硬件上的操作,很多地方还是要用到汇编语言,例如硬件系统的初始化中的CPU 状态的设定,中断的使能,主频的设定,RAM控制参数等。另外在一些对性能非常敏感的代码块,基于汇编与机器码一一对应的关系,这时不能依靠C编译器的生成代码,而要手工编写汇编,从而达到优化的目的。汇编语言是和CPU的指令集紧密相连的,作为涉及底层的嵌入式系统开发,熟练对应汇编语言的使用也是必须的。

单纯的C或者汇编编程请参考相关的书籍或者手册,这里主要讨论C和汇编的混合编程,包括相互之间的函数调用。下面分四种情况来进行讨论,不涉及C++语言。

一、在C语言中内嵌汇编

在C中内嵌的汇编指令包含大部分的ARM和Thumb指令,不过使用与单纯的汇编程序使用的指令略有不同,存在一些限制,主要有下面几个方面:

a 不能直接向PC 寄存器赋值,程序跳转要使用B或者BL指令;

b 在使用物理寄存器时,不要使用过于复杂的C表达式,避免物理寄存器冲突;

c R12和R13可能被编译器用来存放中间编译结果,计算表达式值时可能把R0-R3、R12及R14用于子程序调用,因此避免直接使用这些物理寄存器;

d 一般不要直接指定物理寄存器;

e 让编译器进行分配内嵌汇编使用的标记是__asm或asm关键字,用法如下:__asm{instruction [; instruction]}或 asm("instruction [; instruction]")。

下面是一个例子来说明如何在C中内嵌汇编语言:

//C语言文件*.
#include
void my_strcpy(const char *src, char *dest){
char ch;
__asm{
loop:
ldrb ch, [src], #1
strb ch, [dest], #1
cmp ch, #0
bne loop
}
}
int main(){
char *a="forget it and move on!";
char b[64];
my_strcpy(a, b);
printf("original: %s", a);
printf("copyed: %s", b);
return 0;
}

在此例子中C语言和汇编之间的值传递是用C语言的指针来实现的,因为指针对应的是地址,所以汇编中也可以访问。

二、在汇编中使用C定义的全局变量

内嵌汇编不用单独编辑汇编语言文件,比较简洁,但是有很多的限制。当汇编的代码较多时一般放在单独的汇编文件中,这时就需要在汇编文件和C文件之间进行一些数据的传递,最简便的办法就是使用全局变量。

下面是一个C语言和汇编语言共享全局变量的例子:

//C语言文件*.

#include
int gVar=12;
extern asmDouble(void);
int main(){
printf("original value of gVar is: %d", gVar_1);
asmDouble();
printf(" modified value of gVar is: %d", gVar_1);
return 0;
}

;汇编语言文件*.

AREA asmfile, CODE, READONLY EXPORT asmDouble
IMPORT gVar
asmDouble
ldr r0, =gVar
ldr r1, [r0]
mov r2, #2
mul r3, r1, r2
str r3, [r0]
mov pc, lr
END

在此例中,汇编文件与C文件之间相互传递了全局变量gVar和函数asmDouble,留意声明的关键字extern和IMPORT

三、在C中调用汇编的函数

有一些对机器要求高的敏感函数,通过C语言编写再通过C编译器翻译有时会出现误差,因此这样的函数一般采用汇编语言来编写,然后供C语言调用。在C文件中调用汇编文件中的函数,要注意的有两点,一是要在C文件中声明所调用的汇编函数原型,并加入extern关键字作为引入函数的声明;二是在汇编文件中对对应的汇编代码段标识用EXPORT关键字作为导出函数的声明,函数通过mov pc, lr指令返回。这样,就可以在C文件中使用该函数了。从C语言的角度的角度,并不知道调用的函数的实现是用C语言还是汇编汇编语言,原因C语言的函数名起到表明函数代码起始地址的作用,而这个作用和汇编语言的代码段标识符是一致的。

下面是一个C语言调用汇编函数例子:

//C语言文件*.

#include
extern void asm_strcpy(const char *src, char *dest);
int main(){
const char *s="seasons in the sun"; char d[32];
asm_strcpy(s, d);
printf("source: %s", s);
printf(" destination: %s",d);
return 0;
}

;汇编语言文件*.

AREA asmfile, CODE, READONLY
EXPORT asm_strcpy
asm_strcpy
loop
ldrb r4, [r0], #1
cmp r4, #0
beq over
strb r4, [r1], #1
b loop
over
mov pc, lr
END

在此例中,C语言和汇编语言之间的参数传递是通过对应的用R0-R3来进行传递,即R0传递第一个参数,R1传递第二个参数,多于4个时借助栈完成,函数的返回值通过R0来传递。这个规定叫作ATPCS(ARM Thumb Procedure Call Standard),具体见ATPCS规范。

四、在汇编中调用C的函数

在汇编语言中调用C语言的函数,需要在汇编中IMPORT对应的C函数名,然后将C的代码放在一个独立的C文件中进行编译,剩下的工作由连接器来处理。

下面是一个汇编语言调用C语言函数例子:

//C语言文件*.

int cFun(int a, int b, int c){
return a+b+c;
}
;汇编语言文件*.

AREA asmfile, CODE, READONLY
EXPORT cFun
start
mov r0, #0x1
mov r1, #0x2
mov r2, #0x3
bl cFun
nop
nop
b start
END

在汇编语言中调用C语言的函数,参数的传递也是按照ATPCS规范来实现的。

在这里简单介绍一下部分ATPCS规范:

子程序间通过寄存器R0~R3来传递参数。

A.在子程序中,使用寄存器R4~R11来保存局部变量。

B.寄存器R12用于子程序间scratch寄存器(用于保存SP,在函数返回时使用该寄存器出桟),记作IP。

C.寄存器R13用于数据栈指针,记作SP。寄存器SP在进入子程序时的值和退出子程序时的值必须相等。

D.寄存器R14称为链接寄存器,记作LR。它用于保存子程序的返回地址。

E.寄存器R15是程序计数器,记作PC

F.参数不超过4个时,可以使用寄存器R0~R3来传递参数,当参数超过4个时,还可以使用数据栈来传递参数。

G.结果为一个32位整数时,可以通过寄存器R0返回

H.结果为一个64位整数时,可以通过寄存器R0和R1返回,依次类推。

以上通过几个简单的例子演示了嵌入式开发中常用的C 和汇编混合编程的一些方法和基本的思路,其实最核心的问题就是如何在C 和汇编之间传值,剩下的问题就是各自用自己的方式来进行处理。以上只是抛砖引玉,更详细和复杂的使用方法要结合实际应用并参考相关的资料。

围观 914

页面

订阅 RSS - C语言