西邮Linux兴趣小组2021纳新面试题

西邮Linux兴趣小组2021纳新面试题

#include
#include
int main(void)
{
    char s[]="I love Linux";
    int a=sizeof(s);//16
    int b=strlen(s);//12
    printf("a=%d  b=%dn",a,b);
    return 0;
}

sizeof是一个运算符，求的是数据类型所占空间的大小，即其所占内存空间的字节数；

strlen是一个函数，遇到/0就会结束，返回字符串的长度。

详情见：

strlen和sizeof的区别_飘过的小牛-CSDN博客_strlen和sizeof的区别

C语言中sizeof（）和strlen（）的区别_追梦的小蚂蚁-CSDN博客_sizeof和strlen在c语言的区别

相等（16）

根据内存对齐可知：

test1：a（int）从地址0开始占用0、1、2、3四个单元，b（short）占用4、5单元，c（double）内存对齐占用8、9、10、11、12、13、14、15单元，最后内存对齐补齐到16

test2：b同理占用0-1，a占用4-7，c占用8-15单元，补齐16

内存对齐参考：C/C++内存对齐详解 - 知乎

void func(int a[][13], int m, int n);
void func(int (*a)[13], int m, int n);
void func(int **a, int m, int n);

#include
int ver=123;
void func1(int ver)
{
    ver++;
    printf("ver=%dn",ver);//1026
}

void func2(int*pr)//传入ver的地址给指针pr
{
    *pr=1234;//在此函数内部修改pr指向地址中的值
    printf("*pr=%dn",*pr);//1234
    pr=5678;//警告（直接把int型常量赋值给int*指针）
    
    printf("ver=%dn",ver);//123(全局变量)
}

int main()
{
    int a=0;//函数内部变量
    int ver=1025;
    for(int a=3;a<4;a++)
    {
        static int a=5;//静态全局变量(仅在此循环中起作用)
        printf("a=%dn",a);//5
        a=ver;
        printf("a=%dn",a);//1025
        func1(ver);
        int ver=7;//仅在此循环中起作用
        printf("ver=%dn",ver);//7
        func2(&ver);
    }
    printf("a=%dtver=%dn",a,ver);//0 1025（函数内部变量会覆盖全局变量）
    return 0;
}

#include
unsigned sum(unsigned n)
{
    return n?sum(n-1)+n:0;
    
    
}
int main()
{
    printf("sum=%dn",sum(0));
    printf("%un",sum(100));//5050
    return 0;
}

#include
void func(void);
int main()
{
    func();
    return 0;
}
void func(void)
{
    short a=-2;
    unsigned int b=1;
    b+=a;
    int c=-1;
    unsigned short d=c*256;
    c<<=4;//c的补码右移4位
    int e=2;
    
    e=~e|6;//取反  或运算(参加运算的两个对象只要有一个为1，其值为1)，从左到右运算
    d=(d&0xff)+0x2022;//与运算(两位同时为“1”，结果才为“1”，否则为0)
    printf("a=0x%hxt b=0x%xt d=0x%hxt e=0x%xn",a,b,d,e);//十六进制输出(hx = short x)
    printf("c=0x%hhxtn",(signed char) c);//(hhx = short short x)
}

结果如下：

#include
#define N 3
int main()
{
    int a[N][N]={{1,2,3},{4,5,6},{7,8,9}};
    int (*b)[N]=a;
    

    ++b;//b+1后指向a的第二行开头地址(就是{4,5,6}这一行),(*b)[0]=a[1](b此时为指向数组a第二行的数组指针)
    b[1][1]=10;//此时b[1]指a最后一行(也就是把a最后一行的第一个元素值变为10)
    int*ptr=(int*)(&a+1);//&a指向a整个数组的开头,+1指向下一个数组

    printf("%d %d %dn",a[2][1],**(a+1),*(ptr-1));
    
    return 0;//结果为10 4 9
}

 a 是数组首元素的首地址，即a[0]的首地址。

&a 是数组的首地址。

a+1 是数组下一元素的首地址，即a[1]的首地址。

&a+1 是下一 个数组的首地址。

const int 和int const没有区别都是指此int类型的变量不能被修改
同理const int*和int const*也没有区别，都是指指针指向的值不能被改变
void func2(const int *n)//const在*n前表示不可修改指针n所指向的值
{
    *n+=1;//不能向只读形参赋值
    n=&a;
}
void func3(int*const n)//在n前表示不可修改指针n指向的地址
{
    *n+=1;
    n=&a;//不能向只读位置赋值
}
void func4(const int *const n)
{
    *n+=1;//不能向只读形参赋值
    n=&a;//不能向只读位置赋值
}

更多的const用法：

 C语言中const关键字的用法_xingjiarong的专栏-CSDN博客_c const

const基本用法_灲咲的博客-CSDN博客_const的用法

#include
#include
#include
#include
#define N 44
char *convert(const char *s);
int main()
{
    char *str="XiyouLinux Group 2022";
    char *temp=convert(str);
    puts(temp);
    return 0;
}
char *convert(const char *s)
{
    int len=strlen(s);
    char *k=(char*)malloc(N);//在函数中分配一段空间并且让指针k指向这段字符串的位置
    char *t=s;//指针t用来保存原字符串s的位置
    memset(k,0,N);//将新分配的内存空间中的数全部置为0
    char str[N];//用一个数组来存放转换后的字符串
    for(int i=0;*s!='';*s++,i++)
    {
        if(*s>='a'&&*s<='z')
            str[i]=toupper(*s);
        else if(*s>='A'&&*s<='Z')
            str[i]=tolower(*s);
        else 
            str[i]=*s;
    }
    strcpy(k,str);//将转换后的字符串存放进申请的新内存空间
    t=k;//使存放原s字符串的位置的指针改指向新的位置(新分配的内存空间)
    return t;
}

还可以不使用数组，通过指针的移动储存数据：

char *convert(const char *s)
{
    char *k=(char*)malloc(N);
    char *t=s;
    char *q=k;//再用一个指针保留新分配的内存地址
    memset(k,0,N);
    for(;*s!='';*s++,k++)//通过指针的移动将数据储存在新地址上
    {
        if(*s>='a'&&*s<='z')
            *k=toupper(*s);
        else if(*s>='A'&&*s<='Z')
            *k=tolower(*s);
        else
            *k=*s;
    }
    t=q;//让原指向s的指针指向新地址
    return t;
}

(1)前两种正确，第一种直接从原函数中传递参数，比较方便；第二种在参数中创建交换变量t，作用时间短，且占用内存空间小。第三种是错误的，只传递了a,b变量的值而并没有传递地址，所以仅在函数内部改变了a,b的值而函数作用完后就释放掉函数中变量的内存，a,b的值还是没有改变

(2)do{...}while(0)的用法_majianfei1023的专栏-CSDN博客_do while怎么用

(3)swap(a,b)值交换的四种方法：

void swap(int &a, int &b)
{
//方法一：
    int tmp = 0;
    tmp = b;
    b = a;
    a = tmp;
//方法二：
    a = a+b;
    b = a-b;
    a = a -b;
//方法三：
    a ^= b ^= a ^= b;
//方法四：
    a = a+b-(b=a);
}

 当argv指针不为空的时候一直遍历： 

 

#include
#include
int *func1(void)
{
    static int n=0;//静态变量的作用时间是从调用它开始到本文件结束
    n=1;
    return &n;
}
int *func2(void)
{
    int*p=(int*)malloc(sizeof(int));
    *p=3;
    return p;//返回指向新分配内存的首地址
}

int *func3(void)
{
    int *n;//不能设置为空指针否则赋值不了
    *(n)=4;//给指针指向这个随机地址赋值4
    return n;
}
int main(void)
{
    printf("%dn",*func1());//1
    printf("%dn",*func2());//3
    printf("%dn",*func3());//4
    return 0;
}

关于static静态变量：c语言中static关键字用法详解_guotianqing的博客-CSDN博客_static 

java：static--静态变量与普通变量的区别_yang_B621的博客-CSDN博客_静态变量

#include
int main()
{
    int data[]={0x636c6557,0x20656d6f,0x78206f74,
                0x756f7969,0x6e694c20,0x67207875,
                0x70756f72,0x32303220,0x00000a31};
    puts((const char*)data);//Welcome to xiyou Linux group 2021
    
    return 0;//大小端
}

关于大小端：字节序：大端法和小端法 - Broglie - 博客园 

​​​​​谈谈C语言从源文件变为可执行文件之间发生的过程详解（C程序的编译链接运行）_呋喃吖的博客-CSDN博客

 ​​​​​​关于堆栈的讲解(我见过的最经典的)_yingms的专栏-CSDN博客_堆栈

前提为，另一个文件中的函数，不能是静态函数，即不能有static修饰

调用方法：在调用前进行声明，然后直接调用即可

声明方法：如调用函数为int func(int a)，那么在调用前只需要加上int func(int a);这样声明后，即可使用func。

#include
int max(int x, int y);//调用前声明一下max函数
int main()
{
    int a = 13, b = 130;
    printf("%dn",max(a, b));
    return 0;
}
int max(int x,int y)
{
    return (x>y?x:y);
}

在同一个project里面的源文件之间的函数一般情况下是可以互相调用的，前提是要声明以及不限制它的作用域

来源：c++在一个cpp文件中调用另一个cpp文件的函数的两种方法_lee_swift13的博客-CSDN博客_c++怎么调用另一个cpp中的函数c++工程里一个文件怎么调用另外一个文件里的函数_winder9898的博客-CSDN博客_c++调用另一个文件的函数

西邮Linux兴趣小组2019年面试题总结_TGRD4的博客-CSDN博客

西邮Linux兴趣小组2019补纳面试题总结_TGRD4的博客-CSDN博客

西邮Linux兴趣小组2020纳新面试题总结_TGRD4的博客-CSDN博客