扫描二维码关注公众号，回复： 9845418 查看本文章

1、将字符串反转


#include <stdio.h>
#include <string.h>
void Flip(char*array,int len) {
    int left = 0;
    int right = len;
    while (left <= right) {
        char tmp = array[left];//数组内容进行翻转
        array[left] = array[right];
        array[right] = tmp;
        left++;//对循环条件进行调整
        right--;//对循环条件进行调整
    }
}
int main() {
    char array[] = "tneduts a ma i";
    int len = strlen(array)-1;//取长度注意是取下标最后一位
    Flip(array, len);
    for (int i = 0; i <= len; ++i) {
        printf("%c\n", *(array+i));
    }
    printf("\n");
    system("pause");
    return 0;
}

2、数字翻转和回文判断

int numflip(int num){
int ret=0;
 while(num){
     ret=ret*10+num%10;
     num/=10;

 }
 return ret;
}
int main(int argc, char *argv[])
{
   int num=12;
   int ret= numflip(num);
   printf("%d",ret);
    return 0;
}

回文判断：https://blog.csdn.net/qq_40938077/article/details/80213789

#include <iostream>
#include <string.h>
#include <stack>
using namespace std;
int a[100];
int n;
stack<int>  q; //定义一个栈结构
class heat{
public:
    void Push()//入栈操作
    {
     for(int i=0;i<n;i++){
         q.push(a[i]);
     }
    }
public:
    bool JudgeText();//核心判断回文，通过栈的访问，只有正序与逆序相互匹配才算回文正确，返回true
};
bool heat:: JudgeText()
{
    for(int i=0;i<n;i++){
        if(a[i]!=q.top()){
            return false;
        }
        q.pop();
    }
    return true;
}

int main(int argc, char *argv[])
{

    int n=4;
    int a[4]={1,2,5,4};
    heat p;
    p.Push();
    cout<<p.JudgeText()<<endl;
}

3、大小端问题

（1）判断大小端

大端模式：高字节数据存储在低地址中，而低字节数据存放在高地址中

小端模式：低字节数据存储在低地址中，而高字节数据存放在高地址中

方法一：采用指针强转,这种方式是将 short int 类型的数据取出它的起始字节，如果b位0x11即是高数据则为大端，反之则反

void IsBigEndian()
{
  short int a=0x1122;
  char b=*(char*)&a;
  if(b==0x11)//低字节地址存储的是高字节的数据
  {
    cout<<"大端数据"<<endl;
   }else{
    cout<<"小端数据"<<endl;
  }
}

方法二：用联合体,union数据类型存放的数据的顺都从低地址开始存放的，而且所有的数据成员共享空间

int  isbigendian(){
  union{
      int i;
      char c;
  }test;
  test.i=0x1122;
  return test.c;
}
int main()
{
    int a=isbigendian();
    cout<<a<<endl;//34=ox22  小端模式
}

（2）大小端转换

//16位
#define BSWAP_16(x) \
    (uint_16)((((uint_16)(x) & 0x00ff) << 8) | \
              (((uint_16)(x) & 0xff00) >> 8) \
             )
             
//32位               
#define BSWAP_32(x) \
    (uint_32)((((uint_32)(x) & 0xff000000) >> 24) | \
              (((uint_32)(x) & 0x00ff0000) >> 8) | \
              (((uint_32)(x) & 0x0000ff00) << 8) | \
              (((uint_32)(x) & 0x000000ff) << 24) \
             )

4、实现函数memcpy(), strcpy(), strcmp(), strcat()

（1）函数原型：void *memcpy(void *dest, const void *src, size_t n);

功能：从源src所指的内存地址的起始位置开始，拷贝n个字节到目标dest所指的内存地址的起始位置中，函数返回dest的值。

void* memcpy(void * dest,void* src,int n){
if(NULL==src||NULL==dest){
    return NULL;
}
char *temp=(char *)dest;
const char* s=(const char *) src;//只能够修改值
while(n--){
    *temp++=*s++;
}
return dest;
}

（2）函数原型 ：void strcpy (char *dest,const char*src);

功能：将src拷贝到dest中

char* my_strcpy(char* dest,char* src)
{
    assert(src);//判断源端是否为空地址
    char* cur=dest;
    while(*src != '\0'){
        *dest = *src;
        dest++;
        src++;
    }
    *dest = '\0';
    return cur;
}
int main() {
    char dest[10];
    char src[10]="china";
    printf("%s\n",my_strcpy(dest,src));

（3）函数原型：int strcmp(const char *s,const char * t);
功能：比较字符串s和t，并且根据s按照字典顺序小于，等于或大于t的结果分别返回负整数，0，正整数。

char* my_strcpy(char* dest,char* src)
{
    assert(src);//判断源端是否为空地址
    char* cur=dest;
    while(*src != '\0'){
        *dest = *src;
        dest++;
        src++;
    }
    *dest = '\0';
    return cur;
}
int my_strcpy(const char *str1,const char *str2)
{
    assert(str1);
    assert(str2);
    while(*str1==*str2){
        if(*str1=='\0'){
            return 0;
        }
    }
    if(*str1-*str2){
        return 1;
    }else
        return -1;
}

（4）函数原型：char *strcat(char *dest，char *src);
功能：把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')并添加'\0'，返回指向dest的指针

char *my_strcat(char *des,const char *src)
{
    assert(src);
    char *temp=des;//指针temp指向des字符串内存地址
    while(*des!='\0') des++;
    while(*src!='\0') *des++=*src++;
    *des='\0';
    return temp;

}

5、实现最简单的hello world字符设备驱动

//1、头文件的包含
#include <linux/init.h>
#include <linux/module.h>
 
//许可的声明
MODULE_LICENSE("Dual BSD/GPL");
 
//3、函数注意static、返回值、printk、KERN
static int hello_init(void)
{
	printk(KERN_ALERT "Hello World!\n");
	return 0;
}
static void hello_exit(void)
{
	printk(KERN_ALERT "Goodbye, cruel world\n");
}
//4、注意这两个宏函数的使用
module_init(hello_init);
module_exit(hello_exit);

6、设计函数 int atoi(char *s)，void itoa(int n, char s[])

（1）int atoi(char *s)

描述：把字符串转换成整型数的一个函数。int atoi(const char *nptr) 函数会扫描参数 nptr字符串，跳过前面的空白字符（例如空格，tab缩进）等，可以通过isspace( )函数来检测），直到遇上数字或正负符号才开始做转换，而在遇到非数字或字符串结束符('\0')才结束转换，并将结果返回。如果 nptr不能转换成 int 或者 nptr为空字符串，那么将返回0。特别注意，该函数要求被转换的字符串是按十进制数理解的。

int my_atoi(char arr[])
{
    if(arr==NULL){
        return -1; //非法输入
    }
    /*initial the  variable value */
    int  index=0; //数组下标
    int  num=0;   //转换后的整形值
    int  flag=1;  //正负号
    while(isspace(arr[index]))//遇到非法字符就跳
    {
        index++; //跳过空格字符
    }
    if(arr[index]=='-'){
        flag=-1;
    }
    else if(arr[index]=='+'){
        flag=1;
    }
    if(arr[index]=='-'||arr[index]=='+'){
        index++;
    }
    while(arr[index]>='0'&&arr[index]<='9'){
        num=num*10+arr[index]-'0';
        index++;
    }
    return falg*num;
}

（2）void itoa(int n, char s[])

功能：将整型数字转换为字符串

int my_itoa(int num,int str[])
{
    int i,j;
    int sign;
    if((sign=num)<0){
        n=-n;//改变符号为正
    }
    i=0;
    do{
        s[i++]=n%10+'0';
    }while((n/=10)>0);//删除该数字
    if(sign<0){
        str[i++]='-';
        str[i]='\0';
    }
    /*生成的数子都是逆序的，所以需要逆序输出*/
    for(j=i;j>0;j--){
        printf("%c",s[j]);
    }
}