C语言知识点

标签（空格分隔）： c

---

这篇文档将会不断更新

#include <stdio.h>
int main()
{
    int i=0,a=1,b=2,c=3;
    i=++a||++b||++c;
    printf("%d %d %d %d",i,a,b,c);
}
结果是1 2 2 3
解释：||运算符的"懒惰性" ++a为2而且是或的关系 i肯定为1 就不继续执行了

字符串要注意的###

char ccString1[]="Is Page Fault??";
char ccString2[]="No Page Fault??";
strcpy(ccString1,"No");
if(strcmp(ccString1,ccString2)==0)
   cout<<ccString2;
else
   cout<<ccString1;
   
执行strcpy(ccString1,"No"); ，ccString1变为"No\0Page Fault??"，会将字符串的结束符'\0'放入，所以比较时返回false，执行cout << ccString1; 输出时遇到结束符'\0'就结束，只输出“No”
----------------------------------------------------------------
char dog[]="wang\0miao;
sizeof(dog)为10
strlen(dog)为4
wang,miao占8个字节
'\0'占一个字节 但是会隐形的加上一个'\0'故sizeof(dog)为10
strlen()计算字符串长度遇到'\0'就停下来了

Linux下多少个"-"将被打印：
int main(void){
  int i;
  for(i=0;i<4;i++){
  fork();
  printf("-\n");
 }
 return 0;
}
考察fork()
2+4+8+16 = 30

堆与栈的区别###

堆是使用malloc()、calloc()、realloc()等函数动态分配的，不可能静态分配，使用alloca()函数可以动态分配栈的内存空间，释放的时候由编译器自己释放。

不同平台上的字节数###

（1）16位平台  
char         1个字节8位 
short        2个字节16位 
int          2个字节16位
long         4个字节32位 
指针         2个字节16位  
（2）32位平台  
char         1个字节8位 
short        2个字节16位 
int          4个字节32位 
long         4个字节32位
long long    8个字节64位  
指针         4个字节32位  
（3）64位平台  
char         1个字节 
short        2个字节
 int         4个字节  
long         8个字节（区别） 
long long    8个字节  
指针         8个字节（区别）

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

struct A{
   unsigned int a; //对于开始连续的第一个8字节内存，a占4字节 
   char b[2]；//b[]占1*2字节，在a后的连续2字节内存放，还剩2个
   double c；//c占8字节，第一个8字节还剩2字节不足以存放c,自动补充该2字节。并同时开辟第二个8字节内存存放c
   short d; //d占2字节，开辟第三个8字节，存放d。剩余的6个字节补齐。故总共开辟了8*3=24字节存放该数据结构

};
int main()
{
    printf("%d\n",sizeof(A));
    getchar();
    return 0;
}
结果为24

case 后面的常量表达式实际上只起语句标号作用 , 而不起条件判断作用 , 即 " 只是开始执行处的入口标号 ".  因此 , 一旦与 switch 后面圆括号中表达式的值匹配 , 就从此标号处开始执行 , 而且执行完一个 case 后面的语句后 , 若没遇到 break 语句 , 就自动进入 下一个 case 继续执行 , 而不在判断是否与之匹配 , 直到遇到 break 语句才停止执行 , 退出 break 语句 . 因此 , 若想执行一个 case 分之后立即跳出  switch 语句 , 就必须在此分支的最后添加一个 break 语句 .

#include <stdio.h>
 
int main()
{
 char x = 'B';
 switch (x){
   case 'A':printf("A");
   case 'B':printf("B");
   case 'C':printf("C");
   default: printf("D");
 }
 结果为BCD

void change(int*a, int&b, int c){ 
    c=*a; 
    b=30; 
    *a=20;
}
int main ( ){ 
     int a=10, b=20, c=30; 
     change(&a,b,c); 
     printf(“%d,%d,%d,”,a,b,c)； 
     return 0；
}
传值、传指针、传引用；其中传值不会改变变量的值，传指针和传引用会改变变量的值。
传值的情况，函数的参数会产生临时空间，函数结束就会释放空间，因此不会改变主函数中变量的值；
传指针即传递的是地址，将主函数中变量的地址传到函数中，而不会产生临时变量，因此会改变量的值；
传引用的情况，就是传递的变量的别名，因此也会改变变量的值。

C语言math库中floor函数和fabs的编写

double floor(double x)
{
    return (double)(int)x;
}

double Fabs(double x)  
{  
    return x>1e-10?x:-x;  
}

C语言math exp(x)函数和log(x)函数的编写

double Exp(double X)
{
    double Result=1.0,Precious=X,Xn=1.0,Fac=1.0;
    int n=1;
    while(Precious>1e-6)
    {
        Fac*=n;
        Xn*=X;
        Precious=Xn/Fac;
        Result+=Precious;
        n++;
    }
    return Result;
}

double Log( double a )
{
    int N = 150;
    int k,nk;
    double x,xx,y;
    x = (a-1)/(a+1);
    xx = x*x;
    nk = 2*N + 1;
    y = 1.0/nk;
    for(k=N;k>0;k--)
    {
        nk = nk - 2;
        y = 1.0/nk + xx*y;
    }
    return 2.0*x*y;
}
详情见《实用数值算法》
double Pow(double X,double Y)
{
    return Exp(Y*Log(X));
}

double Sqrt(double X)  
{  
  return Pow(X,0.5);  
}