GroupBlog

int main(int argc , char *argv[]) 
{ 
    unsigned char a = 255; 
    char ch = 128;  
    a -= ch;  
    printf("a = %d ch = %d\n", a, ch);
}

考察点：数据的范围与溢出

知识点：所有数据在计算机内的存储模式均为二进制，char类型说占空间为一个字节，共八个bit位。unsigned为无符号整形，在char中的范围为1～255。若不加unsigned则char的范围为-128～127

答案：127 -128

原因：

输出1：在与a进行计算时，ch被强制转换为了无符号类型与a进行运算，相减的结果为127。

输出2：对于char类型的变量当赋予它的值大于他的范围时便会发生数据的溢出。越过127后即为-128

int main(int argc, char *argv[]) 
{  
    char *str = "Xi You Linux Group 20"; 
    printf("%d\n", printf(str)); 
    return 0;
}

考察点：printf函数的返回值与嵌套时函数调用的顺序

知识点：详见2022年纳新题解

答案：Xi You Linux Group 2021

原因：最先调用里层函数打印出字符串，在调用外层函数打印出里层函数的返回值即为21

#include <stdio.h>
int i=2;
void func(){
    if(i!=0){
        static int m=0;
        int n=0;
        n++;
        m++;
        printf ("%d %d ",m,n);
        i--;
        func();
    }else{
        return ;
    }
}
int main()
{
    func ();
    return 0;
}

考察点：对于全局变量与局部变量的理解与应用

知识点：详见纳新题解2022与2021两篇文章

答案：1 1 2 1

原因：i为全局变量，因递归的条件为i不等于0,所以共调用函数两次。第一次调用时n与m自增。但因为n为静态变量，它在函数第一次被调用后他的值被保存了下来，因此此后每一次调用函数n的值都不会被改变。

#include <stdio.h>
int main()
{
    char ch ='A';
    int i=65;
    unsigned int f=3354433;//f=0000 0010 0000 0000 0000 0000 0000 0001

    *(int *)&f>>=24;//将f右移24为变为0000 0000 0000 0000 0000 0000 0000 0010 即为十进制中的2
    *(int *)&f = *(int *)&f+'?';//？为63
    printf ("%c %c %c",ch,i,*(int *)&f);
}

考察点：ascii码的应用

答案：A A A

原因：%c为字符类型的占位符，输出即为字符A，在ascii码中65对应的便是字符A。f为

#include <stdio.h>
int* get_array(){
    int array[1121];
    for(int i=0;i<sizeof(array)/sizeof(int);i++){
        array[i]=i;
    }
}
int main()
{
    int *p = get_array();
}

考察点：当函数返回类型为指针时的注意事项

知识点：函数在栈区由程序自行调配，当这此函数被调配之后该空间便被释放。若将指针定义在函数中，则在前一个函数调配完之后该函数的位置便会发生改变，返回的地址便会出现错误

答案：给数组array赋值

问题的解决：在堆区动态申请内存

#include<stdio.h>
#include<string.h>
int main()
{
    char str[]="xiyoulinuxgroup";
    char *p=str;
    char x[]="xiyoulinuxgroup\t\106F\bamily";
    printf("%zu %zu %zu %zu\n",sizeof(str),sizeof(p),sizeof(x),strlen(x));
}

考察点：sizeof与srtlen的用法

答案：16 8 25 24

原因：

第一个字符串中有15个字符加上自动补全的\0共占有16个字节

指针类型在不同的架构下为4/8字节

\t代表一个tab，为四个空格差四个字节

srtlen计算长度是不会算入最后一个/0

#include<stdio.h>
int add(int *x,int y){
    return *x=(*x^y)+((*x&y)<<1);
}
int a;//定义全局变量可在整个程序中访问
int main()
{
    int b=2020;
    if(add(&b,1)||add(&a,1)){
        printf("xiyoulinuxgroup%d\n",b);
        printf("wating for y%du\n!",a);
    }
    if(add(&b,1)&&a++){
        printf("xiyoulinuxgroup%d\n",b);
        printf("wating for y%du\n!",a);
    }//a++并未发生，不执行该语句中的内容
}

考察点：

位运算

全局变量

知识点：详见2022纳新与2021纳新两篇文章

答案：

xiyoulinuxgroup2021
wating for y0u

详细运算过程便不在此叙述

void func() 
{   
    int a = 2020; 
    unsigned long c;  
    printf("%p\n", &a); 
    printf("我们想要修改的地址：");
    scanf("%lx", &c); 
    printf("请随便输入一个数字："); 
    scanf("%d", (int *)c); //把c的地址里面存的值以int类型来解释，即将这个数字放到c地址中
    printf("a = %d\n", a);
}
//最终会输出随机输入的那个数字

10.

详见2021年纳新第14题

11.

puts(
    (char*)(int const[])
     {0X6F796958,0X6E694C75,0X72477875,0X3270756F,0X313230,0X00000A}
);//打印XiyouLinuxGroup2021
//大小端问题，详见2022纳新第12题

12.

int main(int argc, char *argv[]) 
{ 
    char str[1121];  
    int key;
    char t;  
    fgets(str, 1121, stdin);  
    for(int i = 0; i < strlen(str) - 1; i++) 
    {   
        key = i;  
        for(int j = i + 1; j < strlen(str);j++) 
        {      
            if(str[key] > str[j]) 
            {      
                key = j;   
            }   
        }    
        t = str[key];  
        str[key] = str[i]; 
        str[i] = t; 
    } 
    puts(str); 
    return 0;
}

利用ascii码对字符大小进行简单的选择排序

13.

#include <stdio.h>
int main()
{
    int n;
    scanf("%d",&n);
    printf("%d",fib(n));
}
int fib(int n)
{
    if(n<=2){
        return 1;
    }else{
        return fib(n-1)+fib(n-2);
    }
}//递归写法

#include<stdio.h>
int main()
{
    int a=0,b=0,c=1,n;//a表示下一项，b表示上一项，c表示这一项
    scanf("%d",&n);
    while(n>0){
        a=b+c;//求出下一项的值
        b=c;//将这一项的值给上一项
        c=a;//将下一项的值给这一项
        n--;
    }
    printf ("%d",a);
}

14.

mkdir [选项] [目录名称] 创建目录
touch创建文件或者修改文件的时间属性
ls-l显示一个文件的属性以及文件所属的用户和组
*ls.Linux查看文件数量**
rmdir删除子目录