C语言小问题集锦

//***********************************************************************//
//***********************************************************************//
//***********************************************************************//
//***********************************************************************//
//关于字符串复制覆盖的问题
#include <stdio.h>
#include<string.h>
void main()
{
char s1[10]="a123d";//"a123d"字符串的长度不能超过s1预定的长度，否则
char s2[10]="abcdefg";//打印或者复制的时候，字符串s1将在连续空间后面找到一个'\0'作为其结束标志
strncpy(s2,s1,strlen(s1));//将s1字符串中前strlen(s1)个字符复制并覆盖s2前strlen(s1)个字符
printf("%s\n",s2);//用strlen计算字符串长度总是以遇到‘\0’为结束标志
}
运行结果：
a123dfg
Press any key to continue
//***********************************************************************//
#include <stdio.h>  
int main()   
{   
int a[5]={9876,0123,4567,8901};//"0123"为八进制数，数组首地址为0x0012ff34
int *ptr;//
printf("%08x\n",a);
printf("%08x\n",&a);
ptr=(&a+3);//&a+1的值为0x0012ff35,但强制转换后赋值给ptr，其值却
printf("%08x\n",(&a+3));//单位步长20个字节，跨越三个步长,共60个字节
printf("%08x\n",ptr);//是0x0012ff70,正好为数组a末尾的下一个地址
    return 0;   
}
运行结果：
0012ff34
0012ff34
0012ff70
0012ff70
Press any key to continue
//***********************************************************************//
#include <stdio.h>  
int main()   
{   
int a[5]={9876,0123,4567,8901};//"0123"为八进制数，数组首地址为0x0012ff34
int *ptr;//
ptr=(int *)(&a+1);//&a+1的值为0x0012ff35,但强制转换后赋值给ptr，其值却
printf("%x\n",ptr);//是0x0012ff38,正好为数组a末尾的下一个地址


    return 0;   
}
//***********************************************************************//
#include<stdio.h>
int main()
{
int a[4][4];
printf("%d,%d,%d\n",sizeof(a),sizeof(*a+1),sizeof(a[0]));//a,地址若为0x0012ff08,则指向其16个元素；
//*a+1，为一指针，地
//址为0x0012ff0c,而仅仅指向a[1][0]这个元素；a[0]则指向第0行的四个元素
return 0;
}
运行结果：
64,4,16
Press any key to continue
//***********************************************************************//
//关于移位操作
#include<stdio.h>
#include<string.h>
void main()
{
int x=0x0ff0;
printf("%x\n",x<<4);//将会输出移位后的数据，但x的值不改变
printf("%04x\n",x);//以宽度4输出十六进制数，不足4位宽度时，左边补上0
printf("%x\n",x<<=4);
printf("%x\n",x);


}


//***********************************************************************//
//sizeof和strlen
#include<stdio.h>
#include<string.h>
void main()
{
char str[]="0123456789";//str空间大小11个字节，长度为10
char *p=str;
printf("%d,%d,%d,%d\n",sizeof(str),strlen(str),sizeof(p),strlen(p));
//sizeof(p),即求指针的大小为4个字节
}
运行结果：
11,10,4,10
Press any key to continue
//***********************************************************************//
#include<stdio.h>
#include<string.h>
void main()
{
char str1[]="1\\tmp012\012";//转义字符'\012'等同于'\n',即换行
char str2[]="2\\tmp012";
char str3[]="3tmp012";
char str4[]="4tmp012\n";//换行
char str5[]="5tmp012\r";//回车
char str6[]="6xxx";//打印效果注意和str5的效果做比较
char str7[]="7tmp012\v";//
char str8[]="8tmp012\b";//退格
char str9[]="9tmp012\x03";
char str10[]="10tmp012\000";
char str11[]="11tmp012\0016";//八进制001被转义为相应的ASCII码，即笑脸,
char str12[]="12tmp012\005345"; //从\开始顺次取三个相连的数字作为转义字符，345直接显示
printf("%d\n",strlen(str1));//重点验证字符串长度
printf("%d\n",strlen(str2));
printf("%d\n",strlen(str3));
printf("%d\n",strlen(str4));
printf("%d\n",strlen(str5));
printf(str1);
printf("\n");
printf(str2);
printf("\n");
printf(str3);
printf("\n");
printf(str4);
printf("\n");//str4的打印后会两次换行
printf(str5);//str5字符串先打印，在回车到行首，即插入点又移到打印行的开头，若又打印字符，则
// printf("\n");//部分或者全部覆盖之前的,若不打印或换行，则不会覆盖
printf(str6);//str6显示的位置其实正是str5的位置
printf("\n");
printf(str7);
printf("\n");
printf(str8);
printf("\n");
printf(str9);
printf("\n");
printf(str10);
printf("\n");
printf(str11);
printf("\n");
printf(str12);
printf("\n");
}


运行结果：
9
8
7
8
8
1\tmp012


2\tmp012
3tmp012
4tmp012


6xxx012
7tmp012
8tmp012
9tmp012.
10tmp012
11tmp012.6
12tmp012.345
Press any key to continue
//***********************************************************************//
//枚举变量的枚举值为递增的序号数值，定义时可以赋给初值，没赋初值的枚举值按照前面最近所赋初值为基数递增推导
#include <stdio.h>  
typedef enum app{
app_min=0,
aa=app_min,
bb,
cc,
max=0x34567890,
dd=max
}t;


void main(void)   
{   
  t x1=app_min;
printf("%d\n",x1);  
x1=aa;
printf("%d\n",x1);
x1=bb;
printf("%d\n",x1);
x1=cc;
printf("%d\n",x1);
x1=max;
printf("%d\n",x1);


}
//***********************************************************************//
#include <stdio.h>  
void Test_SDI(void);
void Camera_Test(void);
struct {
void (*fun)(void);
char *tip;
}CmdTip[] = {
{ Test_SDI, "Test SD Card" } ,
{ Camera_Test, "Test CMOS Camera"},
{ 0, 0}
};
void main()   
{   
  char i;
  for(i=0; CmdTip[i].fun!=0; i++)
  {
printf("%d : %s,0x%x,", i, CmdTip[i].tip,&CmdTip[i].fun);
    (*CmdTip[i].fun)();
printf("\n");
  }
  printf(",0x%x",&Test_SDI);
  printf(",0x%x",Test_SDI);
  printf("\n");


}
void Test_SDI(void)
{
  printf("SDI");
}


void Camera_Test(void)
{
  printf("Camera");
}
//***********************************************************************//
#include<stdio.h>
#include<string.h>
void main()
{

char str2[]={'r','o','c','k','c','h','i','p','s'};  //长度9
printf("%s\n",str2);//打印时以遇到'\0'为结束标志
printf("%d\n",strlen(str2));//用strlen()计算字符串长度总是以遇到‘\0’为结束标志
//所以结果出错
}
运行结果：
rockchips烫虉.
15
Press any key to continue
//***********************************************************************//
//字符串长度问题
#include <stdio.h>  
int main()   
{   
char str1[]="rockchips";//长度10
char str2[]={'r','o','c','k','c','h','i','p','s'};  //长度9
int n1=sizeof(str1)/sizeof(str1[0]);
int n2=sizeof(str2)/sizeof(str2[0]);


int n3=sizeof(str1);
int n4=sizeof(str2);


printf("n1=%d,n2=%d\n",n1,n2);
printf("n3=%d,n4=%d\n",n3,n4);


    return 0;   
}
运行结果：
n1=10,n2=9
n3=10,n4=9
Press any key to continue
//***********************************************************************//
//小端存储
#include <stdio.h>  
int main()   
{   
    int a=0x12345678;   
char b=(char)a;
printf("高字节地址为：0x%x\n",&a);//小端存储，0x12ff44地址对应数据78，0x12ff45对应数据56，0x12ff46对应34....
printf("高字节地址为：0x%x\n",&b);//0x12ff40
printf("高字节地址为：0x%x\n",b);//0x78,强制转换取最低字节数据
    return 0;   
}
//***********************************************************************//
//程序中各种变量的存储位置和程序返回变量的问题 - - 博客频道 - CSDN_NET
#include <stdio.h>  
char *returnStr()   
{   
//    char *p="hello world!";  //"hello world!"是一个字符串常量，存放在只读数据段，指针返回后，内容不被释放
// char p[]="hello world!"; //"hello world!"是局部变量存放在栈中,函数返回时，会被释放清空
static char p[]="hello world!"; //"hello world!"是一个局部静态变量，此处是允许的，返回后，内容不被释放
    return p;   
}   


int main()   
{   
    char *str=NULL;   
    str=returnStr();   
    printf("%s\n", str);   
    return 0;   
}
//***********************************************************************//
//字节对齐，本地变量
#include<stdio.h>
int main() 
{ 
int a; 
char b; 
int c; 
printf("0x%x\n",&a); 
printf("0x%x\n",&b); 
printf("0x%x\n",&c); 
return 0; 
} 
//***********************************************************************//
//变量存储位置
#include <stdio.h> 
int g1=0, g2=0, g3=0; 
int main() 
{ 
static int s1=0, s2=0, s3=0; 
int v1=0, v2=0, v3=0; 
printf("0x%x\n",&v1); //打印各本地变量的内存地址(地址递减) 栈中、动态数据区、运行时分配
printf("0x%x\n",&v2); 
printf("0x%x\n\n",&v3); 
printf("0x%x\n",&g1); //打印各全局变量的内存地址(地址递增) 静态数据区、编译时分配
printf("0x%x\n",&g2); 
printf("0x%x\n\n",&g3); 
printf("0x%x\n",&s1); //打印各静态变量的内存地址(地址递增) 静态数据区、编译时分配
printf("0x%x\n",&s2); 
printf("0x%x\n\n",&s3); 
return 0; 
} 
//***********************************************************************//
//位域，结构体，字节对齐
#include<stdio.h>
struct sttest{
char a;
short c[3];
char *b;
/* union {
char c,d;
unsigned e:2,f:1;
};
struct sttest *link;
*/
};
void main()
{
char c;
c=sizeof(struct sttest);
printf("struct sttest的大小：%d\n",c);
}
运行结果：
struct sttest的大小：12
Press any key to continue
/*
字节对齐的细节和编译器实现相关，但一般而言，满足三个准则：
1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
备注：编译器在给结构体开辟空间时，首先找到结构体中最宽的基本数据类型，然后寻找内存地址能被该基本数据
类型所整除的位置，作为结构体的首地址。将这个最宽的基本数据类型的大小作为上面介绍的对齐模数。
2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之
间加上填充字节（internal adding）；
备注:为结构体的一个成员开辟空间之前，编译器首先检查预开辟空间的首地址相对于结构体首地址的偏移是否是本
成员的整数倍，若是，则存放本成员，反之，则在本成员和上一个成员之间填充一定的字节，以达到整数倍的要求，
也就是将预开辟空间的首地址后移几个字节。
3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节
（trailing padding）。
备注：结构体总大小是包括填充字节，最后一个成员满足上面两条以外，还必须满足第三条，否则就必须在最后填充
几个字节以达到本条要求。
*/
//***********************************************************************//
//32位系统下，各种数据类型的大小
#include<stdio.h>
struct sttest{
unsigned int e:2,f:1;
};
   int Num;
   char *pc;
   int *pint;
   short sDate;
   char cha[2];
   short sBa[4];
   long double ld;
   //unsigned int e:2,f:1;


void main()
{
  char c;
  c=sizeof(int);
  printf("int型大小：%d\n",c);


  c=sizeof(unsigned int);
  printf("unsigned int型大小：%d\n",c);


  c=sizeof(char);
  printf("char型大小：%d\n",c);


  c=sizeof(short);
  printf("short型大小：%d\n",c);


  c=sizeof(long);
  printf("long型大小：%d\n",c);


  c=sizeof(float);
  printf("float型大小：%d\n",c);


  c=sizeof(double);
  printf("double型大小：%d\n",c);


  c=sizeof(long double);
  printf("long double型大小：%d\n",c);


  c=sizeof(ld);
  printf("ld的大小：%d\n",c);


  c=sizeof(cha);
  printf("char型的数组cha[2]大小：%d\n",c);


  c=sizeof(sBa);
  printf("short型的数组sBa[4]大小：%d\n",c);
  c=sizeof(sBa[4]);
  printf("sBa[4]大小：%d\n",c);//针对单个元素
  c=sizeof(&sBa);
  printf("&sBa大小：%d\n",c);
  c=sizeof(&sBa[0]); //?????????
  printf("&sBa[0]大小：%d\n",c);


  c=sizeof(pc);
  printf("char型的指针大小：%d\n",c);
  c=sizeof(*pc); //针对数据的取值
  printf("*pc的大小：%d\n",c);


  c=sizeof(pint);
  printf("int型的指针大小：%d\n",c);


  c=sizeof(struct sttest);
  printf("struct sttest型的指针大小：%d\n",c);
 
}


运行结果：
int型大小：4
unsigned int型大小：4
char型大小：1
short型大小：2
long型大小：4
float型大小：4
double型大小：8
long double型大小：8
ld的大小：8
char型的数组cha[2]大小：2
short型的数组sBa[4]大小：8
sBa[4]大小：2
&sBa大小：8
&sBa[0]大小：4
char型的指针大小：4
pc指针指向的数据的大小：1
int型的指针大小：4
struct sttest型的指针大小：4
Press any key to continue
//***********************************************************************//
//数组指针和指针数组的区别 - jack_Meng - 博客园
#include<stdio.h>
int main()
{
  char a[10]={'a','b','c','d'};
  char (*p1)[5]= &a;//将数组a[]的整个数组首地址地址赋给数组指针p1
  char (*p2)[5]=(char (*)[5])a;//将数组首元素的地址a先强制转换为整个数组的首地址，再赋给p2


  printf("a=%d\n",a);
  printf("a=%c\n",a[0]);
  printf("p1=%c\n",**p1);
  printf("p2=%c\n",**p2);
  printf("p1+1=%c\n",**(p1+1));//指针加一，步长跨越5个字节
  printf("p2+1=%c\n",**(p2+1));
printf("p2+1=0x%x\n",**(p2+2));


    printf("p2+0=%c\n",*(*p2+0));
    printf("p2+1=%c\n",*(*p2+1));
printf("p2+2=%c\n",*(*p2+2));
printf("p2+3=%c\n",*(*p2+3));
printf("p2+4=%d\n",*(*p2+4));


  return 0;
}
//***********************************************************************//
#include<stdio.h>
void main(void)
{
    int p[4] = {0x31,0x32,0x33,0x34};//调试时，指针的地址可以查看
int a=0x41;//调试时，变量的地址不可查看
}
//***********************************************************************//
//无符号数和有符号数之间的算法结果-如果2个操作数中有unsigned类型的默认将两个数都当做unsigned进行处理，
//结果也是无符号的数据.答案是“>26”
#include<stdio.h>
void main()
{
  unsigned int a=6;
  int b=-20;
  (a+b<=6)?puts("<=6"):((a+b<=14)?puts("<=14"):((a+b<=26)?puts("<=26"):puts(">26")));
}


#include<stdio.h>
void main()
{
  unsigned int a=6;
  int b=-20;
  int c=-20;
  printf("a+b=%d\n",a+b);


  b=~b;//按位取反和数值求反 b=-b; 不一样，前者小1，因为无论正负数，在内存中都以补码形式存在
  c=-c;//数值求反
  printf("c=%X\n",c);
  printf("a+b=%d\n",a+b);


  b++;
  printf("a+b=%d\n",a+b);
  (a+b<=6)?puts("<=6"):((a+b<=14)?puts("<=14"):((a+b<=26)?puts("<=26"):puts(">26")));
}
//***********************************************************************//
/*关于反汇编的堆栈使用,相关解释在百度知道雨林沐*/
#include<stdio.h>
long test(int a,int b)
{
a = a + 1;
b = b + 100;
return a + b;
}
void main()
{
printf("%d\n",test(1000,2000));
}
//***********************************************************************//
/*关于“堆栈”的问题*/
#include <stdio.h>
#include <string.h>
struct C
{
int a;
int b;
int c;
};
int test2(int x, int y, int z)
{
printf("hello,test2\n");
return 0;
}
int test(int x, int y, int z)
{
int a = 1;
int b = 2;
int c = 3;
struct C st;
printf("addr x = %u\n",(unsigned int)(&x));
printf("addr y = %u\n",(unsigned int)(&y));
printf("addr z = %u\n",(unsigned int)(&z));
printf("addr a = %u\n",(unsigned int)(&a));
printf("addr b = %u\n",(unsigned int)(&b));
printf("addr c = %u\n",(unsigned int)(&c));
printf("addr st = %u\n",(unsigned int)(&st));
printf("addr st.a = %u\n",(unsigned int)(&st.a));
printf("addr st.b = %u\n",(unsigned int)(&st.b));
printf("addr st.c = %u\n",(unsigned int)(&st.c));
return 0;
}
int main(int argc, char** argv)
{
int x = 1;
int y = 2;
int z = 3;
test(x,y,z);
printf("x = %d; y = %d; z = %d;\n", x,y,z);
memset(&y, 0, 8);
printf("x = %d; y = %d; z = %d;\n", x,y,z);
return 0;
}
//***********************************************************************//
/*关于“#line”的应用*/
#include<stdio.h>
int main(void)
{
#line 98 "a.c"
printf("%s %d\n",__FILE__,__LINE__); //第98行
printf("%s %d\n",__FILE__,__LINE__); //99
printf("%s %d\n",__FILE__,__LINE__); //100
printf("-=-=-=-=-=-=-=-=-=-=-=-\n"); //101
printf("%s %d\n",__FILE__,__LINE__); //102
return 0; //101
}
//***********************************************************************//
#include<stdio.h>
void GetMemory(char **p, int num) 
{
*p = (char *)malloc(num);
}
void main(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
//***********************************************************************//
#define SQ(y) ((y)*(y))
void main()
{
 int i=1;
 while(i<=5)
 {
  printf("%d\n",SQ(i++));
 }
}