整理的经典面试题及各种库函数的自己实现

2024-09-07 08:08

本文主要是介绍整理的经典面试题及各种库函数的自己实现,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

  1. 进程间通信方式

管道(有名管道,无名管道),共享内存,消息队列,信号量,socket通信

  1. 线程同步方式

临界区:通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问

互斥量:为协调共同对一个共享资源的单独访问而设计

信号量(PV操作):为控制一个具有有限数量用户资源而设计

事件:用来通知线程有一些事件已

  1. 进程和线程的区别

资源:进程是拥有资源的一个独立单位,线程是不拥有资源。

调度:线程作为调度和分配的基本单位,进程是作为资源的基本单位

并发性:进程之间可以有并发性进行,同一个进程中的多个线程是可以并发执行

系统开销:进程在创建和撤销的时候,由于系统要分配和回收资源,导致系统的开销明显大于线程

一个进程可以拥有多个线程。

  1. 局部变量和全局变量能否重名

能,局部屏蔽全局。在C++里使用全局,需要使用::。在C语言里,extern

  1. 虚函数和纯虚函数的区别

虚函数必须实现,纯虚函数没有实现

虚函数在子类里可以不重载,但是纯虚函数必须在每一个子类里去实现

在动态内存分配的时候,析构函数必须是虚函数,但没有必要是纯虚函数

  1. 面向对象的三大特性(四大特性)

封装、继承、多态(抽象)

封装:把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏

继承:子类可以拥有父类的属性和方法,但父类没有子类的属性和方法

多态:允许将子类类型的指针赋值给父类类型的指针

实现多态,有二种方式,覆盖,重载

覆盖,是指子类重新定义父类的虚函数的做法

重载,是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)

  1. vi编辑器打开时跳到指定的行

vi +5000 filename

  1. int型在Touble C里占多少个字节

2个字节

  1. 判断一个单链表是否有环

两个指针指向链表头,一个指针每次走一步,另一个指针每次走两步,若有一个指针先指向为NULL表示这个链表无环。若两个指针重合表示链表有环

  1. 刷新缓冲区方式?

换行刷新缓冲区

printf(“\n”);

使用函数刷新缓冲区

fflush(stdout);

程序结束刷新缓冲区

return 0;

  1. 类和对象的两个基本概念什么?

对象就是对客观事物在计算机中的抽象描述。

类就是对具体相似属性和行为的一组对象的统一描述。

类的包括:类说明和类实现两大部分:

类说明提供了对该类所有数据成员和成员函数的描述。

类实现提供了所有成员函数的实现代码。

  1. 数据库三范式

第一范式:没有重复的列

第二范式:非主属的部分依赖于主属部分

第三范式:属性部分不依赖于其他非主属部分

  1. ASSERT( )是干什么用的

是在调试程序使用的一个宏,括号里面要满足,如果不满足,程序将报告错误,并将终止执行。

  1. 如果只想让程序有一个实例运行,不能运行两个。像winamp一样,只能开一个窗口,怎样实现?

用内存映射或全局原子(互斥变量)、查找窗口句柄

FindWindow,互斥,写标志到文件或注册表,共享内存

  1. 如何截取键盘的响应,让所有的’a’变成’b’?

键盘钩子SetWindowsHookEx

  1. 网络编程中设计并发服务器,使用多进程 与 多线程 ,请问有什么区别?

1.进程:子进程是父进程的复制品。子进程获得父进程数据空间、堆和栈的复制品。

2.线程:相对与进程而言,线程是一个更加接近与执行体的概念,它可以与同进程的其他线程共享数据,但拥有自己的栈空间,拥有独立的执行序列。

两者都可以提高程序的并发度,提高程序运行效率和响应时间。

线程和进程在使用上各有优缺点:线程执行开销小,但不利于资源管理和保护;而进程正相反。同时,线程适合于在SMP机器上运行,而进程则可以跨机器迁移。

编程

字符串实现

strcat

char *strcat(char *strDes, const char *strSrc)

{

assert((strDes != NULL) && (strSrc !=NULL));

char *address = strDes;

while (*strDes != ‘\0′)

++ strDes;

while ((*strDes ++ = *strSrc ++) != ‘\0′)

NULL;

return address;

}

strncat

char *strncat(char *strDes, const char *strSrc,int count)

{

assert((strDes != NULL) && (strSrc !=NULL));

char *address = strDes;

while (*strDes != ‘\0′)

++ strDes;

while (count — && *strSrc != ‘\0′ )

*strDes ++ = *strSrc ++;

*strDes = ‘\0′;

return address;

}

strcmp

int strcmp(const char *s, const char *t)

{

assert(s != NULL && t != NULL);

while (*s && *t && *s == *t)

{

++ s;

++ t;

}

return (*s – *t);

}

strncmp

int strncmp(const char *s, const char *t, intcount)

{

assert((s != NULL) && (t != NULL));

while (*s && *t && *s == *t&& count –)

{

++ s;

++ t;

}

return (*s – *t);

}

strcpy

char *strcpy(char *strDes, const char *strSrc)

{

assert((strDes != NULL) && (strSrc !=NULL));

char *address = strDes;

while ((*strDes ++ = *strSrc ++) != ‘\0′)

NULL;

return address;

}

 

strncpy

char *strncpy(char *strDes, const char *strSrc,int count)

{

assert(strDes != NULL && strSrc !=NULL);

char *address = strDes;

while (count — && *strSrc != ‘\0′)

*strDes ++ = *strSrc ++;

return address;

}

strlen

int strlen(const char *str)

{

assert(str != NULL);

int len = 0;

while (*str ++ != ‘\0′)

++ len;

return len;

}

strpbrk

char *strpbrk(const char *strSrc, const char*str)

{

assert((strSrc != NULL) && (str !=NULL));

const char *s;

while (*strSrc != ‘\0′)

{

s = str;

while (*s != ‘\0′)

{

if (*strSrc == *s)

return (char *) strSrc;

++ s;

}

++ strSrc;

}

return NULL;

}

strstr

char *strstr(const char *strSrc, const char*str)

{

assert(strSrc != NULL && str != NULL);

const char *s = strSrc;

const char *t = str;

for (; *t != ‘\0′; ++ strSrc)

{

for (s = strSrc, t = str; *t != ‘\0′ &&*s == *t; ++s, ++t)

NULL;

if (*t == ‘\0′)

return (char *) strSrc;

}

return NULL;

}

strcspn

int strcspn(const char *strSrc, const char*str)

{

assert((strSrc != NULL) && (str !=NULL));

const char *s;

const char *t = strSrc;

while (*t != ‘\0′)

{

s = str;

while (*s != ‘\0′)

{

if (*t == *s)

return t – strSrc;

++ s;

}

++ t;

}

return 0;

}

strspn

int strspn(const char *strSrc, const char *str)

{

assert((strSrc != NULL) && (str !=NULL));

const char *s;

const char *t = strSrc;

while (*t != ‘\0′)

{

s = str;

while (*s != ‘\0′)

{

if (*t == *s)

break;

++ s;

}

if (*s == ‘\0′)

return t – strSrc;

++ t;

}

return 0;

}

strrchr

char *strrchr(const char *str, int c)

{

assert(str != NULL);

const char *s = str;

while (*s != ‘\0′)

++ s;

for (– s; *s != (char) c; — s)

if (s == str)

return NULL;

return (char *) s;

}

strrev

char* strrev(char *str)

{

assert(str != NULL);

char *s = str, *t = str, c;

while (*t != ‘\0′)

++ t;

for (– t; s < t; ++ s, — t)

{

c = *s;

*s = *t;

*t = c;

}

return str;

}

strnset

char *strnset(char *str, int c, int count)

{

assert(str != NULL);

char *s = str;

for (; *s != ‘\0′ && s – str <count; ++ s)

*s = (char) c;

return str;

}

strset

char *strset(char *str, int c)

{

assert(str != NULL);

char *s = str;

for (; *s != ‘\0′; ++ s)

*s = (char) c;

return str;

}

strtok

char *strtok(char *strToken, const char *str)

{

assert(strToken != NULL && str !=NULL);

char *s = strToken;

const char *t = str;

while (*s != ‘\0′)

{

t = str;

while (*t != ‘\0′)

{

if (*s == *t)

{

*(strToken + (s – strToken)) = ‘\0′;

return strToken;

}

++ t;

}

++ s;

}

return NULL;

}

strupr

char *strupr(char *str)

{

assert(str != NULL);

char *s = str;

while (*s != ‘\0′)

{

if (*s >= ‘a’ && *s <= ‘z’)

*s -= 0×20;

s ++;

}

return str;

}

strlwr

char *strlwr(char *str)

{

assert(str != NULL);

char *s = str;

while (*s != ‘\0′)

{

if (*s >= ‘A’ && *s <= ‘Z’)

*s += 0×20;

s ++;

}

return str;

}

memcpy

void *memcpy(void *dest, const void *src, intcount)

{

assert((dest != NULL) && (src !=NULL));

void *address = dest;

while (count –)

{

*(char *) dest = *(char *) src;

dest = (char *) dest + 1;

src = (char *) src + 1;

}

return address;

}

memccpy

void *memccpy(void *dest, const void *src, intc, unsigned int count)

{

assert((dest != NULL) && (src !=NULL));

while (count –)

{

*(char *) dest = *(char *) src;

if (* (char *) src == (char) c)

return ((char *)dest + 1);

dest = (char *) dest + 1;

src = (char *) src + 1;

}

return NULL;

}

memchr

void *memchr(const void *buf, int c, int count)

{

assert(buf != NULL);

while (count –)

{

if (*(char *) buf == c)

return (void *) buf;

buf = (char *) buf + 1;

}

return NULL;

}

memcmp

int memcmp(const void *s, const void *t, intcount)

{

assert((s != NULL) && (t != NULL));

while (*(char *) s && *(char *) t&& *(char *) s == *(char *) t && count –)

{

s = (char *) s + 1;

t = (char *) t + 1;

}

return (*(char *) s – *(char *) t);

}

memmove

void *memmove(void *dest, const void *src, intcount)

{

assert(dest != NULL && src != NULL);

void *address = dest;

while (count –)

{

*(char *) dest = *(char *) src;

dest = (char *) dest + 1;

src = (const char *)src + 1;

}

return address;

}

memset

void *memset(void *str, int c, int count)

{

assert(str != NULL);

void *s = str;

while (count –)

{

*(char *) s = (char) c;

s = (char *) s + 1;

}

return str;

}

 

strdup

char *strdup(const char *strSrc)

{

assert(strSrc != NULL);

int len = 0;

while (*strSrc ++ != ‘\0′)

++ len;

char *strDes = (char *) malloc (len + 1);

while ((*strDes ++ = *strSrc ++) != ‘\0′)

NULL;

return strDes;

}

strchr_

char *strchr_(char *str, int c)

{

assert(str != NULL);

while ((*str != (char) c) && (*str !=‘\0′))

str ++;

if (*str != ‘\0′)

return str;

return NULL;

}

strchr

char *strchr(const char *str, int c)

{

assert(str != NULL);

for (; *str != (char) c; ++ str)

if (*str == ‘\0′)

return NULL;

return (char *) str;

}

atoi

int atoi(const char* str)

{

    int x=0;

    const char* p=str;

    if(*str==’-’||*str==’+’)

    {

     str++;

    }

    while(*str!=0)

    {

        if((*str>’9′)||(*str<’0′))

        {

        break;

        }

        x=x*10+(*str-’0′);

        str++;

    }

    if(*p==’-’)

    {

        x=-x;

    }

    return x;

}

itoa

char* itoa(int val,char* buf,unsigned intradix)

{

char *bufptr;

char *firstdig;

char temp;

unsigned int digval;

assert(buf != NULL);

bufptr = buf;

if (val < 0)

{

*bufptr++ = ‘-’; val = (unsignedint)(-(int)val);

}

firstdig = bufptr;

do

{

digval =(unsigned int) val % radix; val /=radix;

if (digval > 9)

{

*bufptr++ = (char)(digval – 10 + ‘a’);

}

else

{

*bufptr++ = (char)(digval + ’0′);

}

} while(val > 0);

*bufptr– = ‘\0′;//设置字符串末尾,并将指针指向最后一个字符

do //反转字符

{

temp = *bufptr; *bufptr = *firstdig; *firstdig= temp;

–bufptr; ++firstdig;

} while(firstdig < bufptr);

return buf;

}

String实现

已知String原型为:

class String

{

public:

//普通构造函数

String(const char *str =NULL)

//拷贝构造函数

String(const String&other)

//析构函数

~String(void);

//赋值函数

String &operator=(String &other) //oh,原题目打错了,string可是一个关键字

private:

char* m_str;

unsigned m_uCount;

};

分别实现以上四个函数

//普通构造函数

String::String(const char* str)

{

    if(str==NULL)                //如果strNULL,存空字符串

{

        m_str= new char[1];        //分配一个字节

        *m_str=‘\0′;            //赋一个’\0′

}else

    {

        m_str= new char[strlen(str) + 1];//分配空间容纳str内容

        strcpy(m_str,str);         //复制str到私有成员m_str

    }

}

//析构函数

String::~String()

{

    if(m_str!=NULL)    //如果m_str不为NULL,释放堆内存

{

        delete[] m_str;

        m_str= NULL;

}

}

//拷贝构造函数

String::String(const String &other)

{

    m_str = new char[strlen(other.m_str)+1];    //分配空间容纳str内容

    strcpy(m_str,other.m_str);            //复制other.m_str到私有成员m_str    

}

//赋值函数

String & String::operator=(String&other)

{

    if(this ==&other)                //若对象与other是同一个对象,直接返回本身

{

        return*this

}

    delete []m_str;                //否则,先释放当前对象堆内存

    m_str = newchar[strlen(other.m_str)+1];    //分配空间容纳str内容

    strcpy(m_str,other.m_str);            //复制other.m_str到私有成员m_str

    return *this

}

编写一个二分查找的功能函数

int BSearch(elemtype a[],elemtype x,int low,inthigh)

/*在下届为low,上界为high的数组a中折半查找数据元素x*/

{

int mid;

if(low>high)

return -1;

mid=(low+high)/2;

if(x==a[mid])

return mid;

if(x<a[mid])

return(BSearch(a,x,low,mid-1));

else

return(BSearch(a,x,mid+1,high));

}

2) 非递归方法实现:

int BSearch(elemtype a[],keytype key,int n)

{

int low,high,mid;

low=0;high=n-1;

while(low<=high)

{

mid=(low+high)/2;

if(a[mid].key==key)

return mid;

else if(a[mid].key<key)

low=mid+1;

else

high=mid-1;

}

return -1;

}

字符串逆序

方法一

#include <stdio.h>

#include <string.h>

void main()

{

    charstr[]=”hello,world”;

    int len=strlen(str);

    char t;

    int i;

    for(i=0; i<len/2;i++)

    {

        t=str[i];

        str[i]=str[len-i-1];

str[len-i-1]=t;

    }

    printf(“%s\n”,str);

    return 0;

}

方法二

#include <stdio.h>

int main(){

char* src = “hello,world”;

int len = strlen(src);

char* dest =(char*)malloc(len+1);//要为\0分配一个空间

char* d = dest;

char* s =&src[len-1];//指向最后一个字符

while( len– != 0 )

*d++=*s–;

*d = 0;//尾部要加\0

printf(“%s\n”,dest);

free(dest);// 使用完,应当释放空间,以免造成内存汇泄露

return 0;

}

排序

冒泡排序

void bubble_sort(int a[],int n)

{

int i,j;

for(i=0;i<n-1;i++)

{

bool x=ture;

for(j=0;j<n-1-i;j++)

{

int temp;

if(a[j]>a[j+1])

{

temp=a[j];

a[j]=a[j+1];

a[j+1]=temp;

x=false;

}

}

if(x) break;

}

}

时间复杂度O(N^2)

选择排序

void select_sort(int a[],int n)

{

int i,j;

for(i=0;i<n-1;i++)

{

int min=i;

for(j=i+1;j<n;j++)

{

if(a[j]<a[min])

min=j;

if(min!=i)

{

int temp=a[j];

a[j]=a[min];

a[min]=temp;

}

}

}

}

时间复杂度O(N^2)

插入排序

void insert_sort(int a[],int n)

{

int i,j;

for(i=1;i<n;i++)

{

int x=a[i];

for(j=i;j>0&&x<a[j-1];j–)

a[j]=a[j-1];

a[j]=x;

}

}

时间复杂度O(N^2)

快速排序

void quick_sort(int a[],int ileft,int iright)

{

int iPivot=(left+right)/2;

int nPivot=a[iPivot];

for(int i=ileft,j=iright;i<j;)

{

while(!(i>=iPivot||nPivot<a[i]))

i++;

if(i<iPivot)

{

a[iPivot]=a[i];

iPivot=i;

}

while(!(j<=iPivot||nPivot>a[j]))

j–;

if(j>iPivot)

{

a[iPivot]=a[j];

iPivot=j;

}

}

a[iPivot]=nPivot;

if(iPivot-ileft>1)

quick_sort(a,ileft,iPivot-1);

if(iright-iPivot>1)

quick_sort(a,iPivot+1,iright);

}

时间复杂度O(NlogN)

链表

单链表

双链表

循环链表

单链表逆置

void reverse(link *head)

{

    link *p, *s, *t;

    p = head;

    s = p->next;

    while(s->next!=NULL)

    {

        t= s->next;

        s->next= p;

        p= s;

        s= t;

    }

    s->next = p;

    head->next->next= NULL;    //尾指针置为空

    head->next = s;        //赋值到头指针后一位

}

链表合并

Node * Merge(Node *head1 , Node *head2)

{

if ( head1 == NULL)

return head2 ;

if ( head2 == NULL)

return head1 ;

Node *head = NULL ;

Node *p1 = NULL;

Node *p2 = NULL;

if ( head1->data <head2->data )

{

head = head1 ;

p1 = head1->next;

p2 = head2 ;

}else

{

head = head2 ;

p2 = head2->next ;

p1 = head1 ;

}

Node *pcurrent = head ;

while ( p1 != NULL&& p2 != NULL)

{

if ( p1->data <=p2->data )

{

pcurrent->next = p1 ;

pcurrent = p1 ;

p1 = p1->next ;

}else

{

pcurrent->next = p2 ;

pcurrent = p2 ;

p2 = p2->next ;

}

}

if ( p1 != NULL )

pcurrent->next = p1 ;

if ( p2 != NULL )

pcurrent->next = p2 ;

return head ;

}

 

递归方式:

Node * MergeRecursive(Node *head1 , Node*head2)

{

if ( head1 == NULL )

return head2 ;

if ( head2 == NULL)

return head1 ;

Node *head = NULL ;

if ( head1->data <head2->data )

{

head = head1 ;

head->next =MergeRecursive(head1->next,head2);

}

else

{

head = head2 ;

head->next =MergeRecursive(head1,head2->next);

}

return head ;

}

写一个Singleton模式

#include<iostream>

using namespace std;

class Singleton

{

    private:

    static Singleton*_instance;

    protected:

    Singleton()

{

    cout<<”Singleton”<<endl;

}

    public:

    static Singleton*Instance()

{

if(NULL==_instance)

{

    _instance=newSingleton();

}

return _instance;

}

};

static Singleton* Singleton::_instance=NULL;

int main()

{

    Singleton * s=Singleton::Instance();

    Singleton *s1=Singleton::Instance();

}

如何对String类型数据的某个字符进行访问?

#include<iostream>

using namespace std;

int main()

{

    strings=”abcdefg”;    

    const char*c=s.c_str();

    while(*c!=’\0′)

    {

        printf(“%c”,*c++);

    }

}

文件加密、解密

1.加密(encryption):

#include<stdio.h>

void encryption(char *ch)

{

    (*ch)^=0xFF; //算法可自行修改调整,使用AES加密算法

}

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

{

    if(argc<2)

    {

        printf(“参数不足”);

        return-1;

    }

    //文件的打开(fopen函数)

    /*

    r    read    只读

    w    write    只写

    a    append    追加

    t    text    文本文件,可省略不写

    b    banary    二进制文件

    +    读和写

     */

a.out a.c b.txt

argv[0] argv[1] argv[2]

 

 

 

    FILE* fpr=NULL;

    FILE* fpw=NULL;

    //文件打开失败返回一个空指针值NULL

    if(NULL==(fpr=fopen(argv[1],”r”))){printf(“%m\n”);return-1;}

    if(NULL==(fpw=fopen(argv[2],”w+”))){printf(“%m\n”);return-1;}

    char ch;

    while((ch=fgetc(fpr))!=EOF)

    {

        //putchar(ch);

        encryption(&ch);//加密函数

        printf(“%c”,ch);//加密后字符显示

        fputc(ch,fpw);//存放进文件

    }

    printf(“\n文件加密成功!\n”);

 

    //文件的关闭(fclose函数)

    fclose(fpr);

    fclose(fpw);

}

 

2.解密(decryption):

#include<stdio.h>

#include<time.h>

 

void show()

{

    time_tstart=time(NULL);

    while(start==time(NULL));

}

void decryption(char ch)

{

    (*ch)^=0xFF;//算法可自行修改调整

}

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

{

    if(argc<2)

    {

        printf(“参数不足”);

        return-1;

    }

    //文件的打开(fopen函数)

    /*

    r    read    只读

    w    write    只写

    a    append    追加

    t    text    文本文件,可省略不写

    b    banary    二进制文件

    +    读和写

     */

    FILE* fpr=NULL;

    FILE* fpw=NULL;

    //文件打开失败返回一个空指针值NULL

    if(NULL==(fpr=fopen(argv[1],”r”))){printf(“%m\n”);return-1;}

    if(NULL==(fpw=fopen(argv[2],”w+”))){printf(“%m\n”);return-1;}

    char ch;

    printf(“开始解密!\n”);

    while((ch=fgetc(fpr))!=EOF)

    {

        show();

        ch=decryption(ch);//解密函数

        printf(“%c”,ch);//解密后字符显示

        fputc(ch,fpw);//存放进文件

        fflush(stdout);//刷新显示

    }

    printf(“\n文件解密成功!\n”);

 

    //文件的关闭(fclose函数)

    fclose(fpr);

    fclose(fpw);

}

斐波那契数列(Fibonacci sequence

int Funct( int n )

{

if( n==0 || n==1 ) return 1;

retrurn Funct(n-1) + Funct(n-2);

}

 

 

 

这篇关于整理的经典面试题及各种库函数的自己实现的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1144522

相关文章

hdu1043(八数码问题,广搜 + hash(实现状态压缩) )

利用康拓展开将一个排列映射成一个自然数,然后就变成了普通的广搜题。 #include<iostream>#include<algorithm>#include<string>#include<stack>#include<queue>#include<map>#include<stdio.h>#include<stdlib.h>#include<ctype.h>#inclu

【C++】_list常用方法解析及模拟实现

相信自己的力量,只要对自己始终保持信心,尽自己最大努力去完成任何事,就算事情最终结果是失败了,努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一:什么是list? •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二:list常用接口 •🌰1.默认成员函数 🔥构造函数(⭐) 🔥析构函数 •🌰2.list对象

【Prometheus】PromQL向量匹配实现不同标签的向量数据进行运算

✨✨ 欢迎大家来到景天科技苑✨✨ 🎈🎈 养成好习惯,先赞后看哦~🎈🎈 🏆 作者简介:景天科技苑 🏆《头衔》:大厂架构师,华为云开发者社区专家博主,阿里云开发者社区专家博主,CSDN全栈领域优质创作者,掘金优秀博主,51CTO博客专家等。 🏆《博客》:Python全栈,前后端开发,小程序开发,人工智能,js逆向,App逆向,网络系统安全,数据分析,Django,fastapi

让树莓派智能语音助手实现定时提醒功能

最初的时候是想直接在rasa 的chatbot上实现,因为rasa本身是带有remindschedule模块的。不过经过一番折腾后,忽然发现,chatbot上实现的定时,语音助手不一定会有响应。因为,我目前语音助手的代码设置了长时间无应答会结束对话,这样一来,chatbot定时提醒的触发就不会被语音助手获悉。那怎么让语音助手也具有定时提醒功能呢? 我最后选择的方法是用threading.Time

Android实现任意版本设置默认的锁屏壁纸和桌面壁纸(两张壁纸可不一致)

客户有些需求需要设置默认壁纸和锁屏壁纸  在默认情况下 这两个壁纸是相同的  如果需要默认的锁屏壁纸和桌面壁纸不一样 需要额外修改 Android13实现 替换默认桌面壁纸: 将图片文件替换frameworks/base/core/res/res/drawable-nodpi/default_wallpaper.*  (注意不能是bmp格式) 替换默认锁屏壁纸: 将图片资源放入vendo

C#实战|大乐透选号器[6]:实现实时显示已选择的红蓝球数量

哈喽,你好啊,我是雷工。 关于大乐透选号器在前面已经记录了5篇笔记,这是第6篇; 接下来实现实时显示当前选中红球数量,蓝球数量; 以下为练习笔记。 01 效果演示 当选择和取消选择红球或蓝球时,在对应的位置显示实时已选择的红球、蓝球的数量; 02 标签名称 分别设置Label标签名称为:lblRedCount、lblBlueCount

Kubernetes PodSecurityPolicy:PSP能实现的5种主要安全策略

Kubernetes PodSecurityPolicy:PSP能实现的5种主要安全策略 1. 特权模式限制2. 宿主机资源隔离3. 用户和组管理4. 权限提升控制5. SELinux配置 💖The Begin💖点点关注,收藏不迷路💖 Kubernetes的PodSecurityPolicy(PSP)是一个关键的安全特性,它在Pod创建之前实施安全策略,确保P

数论入门整理(updating)

一、gcd lcm 基础中的基础,一般用来处理计算第一步什么的,分数化简之类。 LL gcd(LL a, LL b) { return b ? gcd(b, a % b) : a; } <pre name="code" class="cpp">LL lcm(LL a, LL b){LL c = gcd(a, b);return a / c * b;} 例题:

工厂ERP管理系统实现源码(JAVA)

工厂进销存管理系统是一个集采购管理、仓库管理、生产管理和销售管理于一体的综合解决方案。该系统旨在帮助企业优化流程、提高效率、降低成本,并实时掌握各环节的运营状况。 在采购管理方面,系统能够处理采购订单、供应商管理和采购入库等流程,确保采购过程的透明和高效。仓库管理方面,实现库存的精准管理,包括入库、出库、盘点等操作,确保库存数据的准确性和实时性。 生产管理模块则涵盖了生产计划制定、物料需求计划、

C++——stack、queue的实现及deque的介绍

目录 1.stack与queue的实现 1.1stack的实现  1.2 queue的实现 2.重温vector、list、stack、queue的介绍 2.1 STL标准库中stack和queue的底层结构  3.deque的简单介绍 3.1为什么选择deque作为stack和queue的底层默认容器  3.2 STL中对stack与queue的模拟实现 ①stack模拟实现