软件工程师笔试编程题

面试 同时被 3 个专栏收录
14 篇文章 1 订阅
61 篇文章 2 订阅
144 篇文章 8 订阅

1. 已知strcpy的函数原型:char *strcpy(char *strDest, const char *strSrc)其中strDest 是目的字符串,strSrc 是源字符串。不调用C++/C 的字符串库函数,请编写函数 strcpy。

char *strcpy(char *strDest, const char *strSrc)
{
if ( strDest == NULL || strSrc == NULL)
return NULL ;
if ( strDest == strSrc)
return strDest ;
char *tempptr = strDest ;
while( (*strDest++ = *strSrc++) != ‘\0);
return tempptr ;
}

2.写一个函数找出一个整数数组中,第二大的数 (microsoft)

const int MINNUMBER = -32767 ;
int find_sec_max( int data[] , int count)
{
int maxnumber = data[0] ;
int sec_max = MINNUMBER ;
for ( int i = 1 ; i < count ; i++)
{
if ( data[i] > maxnumber )
{
sec_max = maxnumber ;
maxnumber = data[i] ;
}
else
{
if ( data[i] > sec_max )
sec_max = data[i] ;
}
}
return sec_max ;
}

3.回文字符串—递归法

#include<stdio.h>
#include<string.h>
int main()
{   int i=0,n,k=0;
    char a[20],*p,*q;
    scanf("%s",a);
    n=strlen(a);
    p=a; q=p+n-1;
 while(i<(n/2+1)&&q>p)
    if(*p==*q)  { k++;i++; p++; q--; } 
if(k==n/2)  printf("Yes\n");
else  printf("No\n");
 system("pause");
 return 0;
}

4.用指针判断回文字符的程序

#include <stdio.h> 
#include <stdlib.h> 
#include <conio.h> 
#define MAX 50 
int cycle(char *s) 
{   char *h,*t; 
for(h=s,t=s+strlen(s)-1;t>h;h++,t--) 
if(*h!=*t) break; 
return t<=h; 
} 
main() 
{   char s[MAX]; 
clrscr(); 
while(1) 
{ puts("Please input the string you want to judge (input ^ to quit):"); 
scanf("%s",s); /*当输入的字符串的第一个字符是^时,退出*/ 
if(s[0]=='^')  break; 
if(cycle(s)) 
printf(" %s is a cycle string.\n",s); 
else 
printf(" %s is not a cycle string.\n",s); 
}
getch(); 
}

判断一个字符串是不是回文

int IsReverseStr(char *aStr)
{
int i,j;   int found=1;
if(aStr==NULL)
return -1;
j=strlen(aStr);
for(i=0;i<j/2;i++)
if(*(aStr+i)!=*(aStr+j-i-1))
{
found=0;break;
}
return found;
}

b)请编写一个 C 函数,该函数将给定的一个字符串转换成整数。

int Invert(char *str) 
{ 	int num=0; 
while(*str!='\0') 
{ 	int digital=*str-48; 
num=num*10+digital; 
str=str+1; 
} 
return num; 
} 

一个字符串中最大重复子串

#include <stdio.h> 
#include <string.h> 
void find(const char *str) 
{ 
    int len= (int)strlen(str); 
    int x;
    int c;
    char *result = new char[len - 1] ; 
    
    for (int i = len / 2 ; i >= 1 ; i--) 
    { 
        for ( x = 0 ; x < len - i ; x++) 
            result[x] = (str[x + i] == str[x]) ; 
        for ( x = 0, c = 0 ; x < len - i ; x++) 
        { 
            if (result[x]) c++ ; else c = 0 ; 
            if (c == i) 
            { 
                for (int y = 0 ; y < i ; y++)   
                    printf("%c", str[x - i + y + 1]) ; 
                delete[ ] result ; 
                return ; 
            } 
        } 
    } 
    delete[ ] result ; 
    printf("No match!") ; 
} 

void main( ) 
{ 
    find("ababc") ; 
}

递归求阶乘

#include <stdio.h>
float fac(int n)
{
  float f;
  if(n<0)
   {  printf("n<0,data error!");
     return -1;}
     else if(n==0 ||n==1)
         f=1;
       else 
        f=n*fac(n-1);
        return f;
}
main()
{  int n=10;
  float f;
  f=fac(n);
  printf("10!=%10.0f\n",f);
 }

让你在100000000个浮点数中找出最大的10000个,要求时间复杂度优。

//本算法使用快排,O(n*lg(n))  
//最低可以找到线性算法,使用预先区域统计划分!类试于构造Quad Trees! 写起来代码会长些! 
 
#include <stdio.h> 
#include <stdlib.h> 
 
#define Max 100000000 
int a[Max+10]; 
 
int cmp( const void *a, const void *b) 
{ 
     int *x = ( int *) a; 
     int *y = ( int *) b; 
     return *x-*y; 
} 
 
int main() 
{ 
     int n=0; 
     while (scanf("%d",&a[n])==1)     n++; 
     qsort(a,n,4,cmp); 
     for ( int i=0;i<3;i++)     printf("%d",a[ i ]); 
     return 1; 
} 

请编写一个 C 函数,该函数在给定的内存区域搜索给定的字符,并返回该字符所在位置索引值。

int search(char *cpSource, int n, char ch)
{
int i;
for(i=0; i<n && *(cpSource+i) != ch; ++i);
return i;
}

3、用递归算法判断数组a[N]是否为一个递增数组。递归的方法,记录当前最大的,并且判断当前的是否比这个还大,大则继续,否则返回false结束:

bool fun( int a[], int n )
{
if( n= =1 )
return true;
if( n= =2 )
return a[n-1] >= a[n-2];
return fun( a,n-1) && ( a[n-1] >= a[n-2] );
}

11.编写my_memcpy函数,实现与库函数memcpy类似的功能,不能使用任何库函数;

 void* mymemcpy(void* pvTo, const char* pvFrom, size_t size)
 { assert((dest != NULL) && (src != NULL));
 byte* psTo = (byte*)pvTo;
 byte* psFrom = (byte*)pvFrom;
 while (size-- > 0) 
 {*psTo++ = *psFrom++;}
  return pvTo;
 }

12.编写my_strcpy函数,实现与库函数strcpy类似的功能,不能使用任何库函数;

 答:char* my_strcpy(char* strdest, const char* strsrc)
 { assert((strdest != NULL) && (strsrc != NULL))
   char* address = strdest;
   while((*strdest++ = *strsrc++) != NULL)
   return address;
 }

编写一个 C 函数,该函数在一个字符串中找到可能的最长的子字符串,且该字符串是由同一字符组成的。

char * search(char *cpSource, char ch)
{
char *cpTemp=NULL, *cpDest=NULL;
int iTemp, iCount=0;
while(*cpSource)
{
if(*cpSource == ch)
{
iTemp = 0;
cpTemp = cpSource;
while(*cpSource == ch) 
++iTemp, ++cpSource;
if(iTemp > iCount) 
iCount = iTemp, cpDest = cpTemp;
if(!*cpSource) 
break;
}
++cpSource;
}
return cpDest;
} 

1、用指针的方法,将字符串“ABCD1234efgh”前后对调显示

#include <stdio.h>
#include <string.h>
#include <dos.h>
int main()
{
char str[] = "ABCD1234efgh";
int length = strlen(str);
char * p1 = str;
char * p2 = str + length - 1;
while(p1 < p2)
{
char c = *p1;
*p1 = *p2;
*p2 = c;
++p1;
--p2;
}
printf("str now is %s\n",str);
system("pause");
return 0;
}

3. 编程实现:把十进制数(long型)分别以二进制和十六进制形式输出,不能使用printf系列库函数

char* test3(long num) {
char* buffer = (char*)malloc(11);
buffer[0] = '0';
buffer[1] = 'x';
buffer[10] = '\0';

char* temp = buffer + 2;
for (int i=0; i < 8; i++) {
temp[i] = (char)(num<<4*i>>28);
temp[i] = temp[i] >= 0 ? temp[i] : temp[i] + 16;
temp[i] = temp[i] < 10 ? temp[i] + 48 : temp[i] + 55;
}
return buffer;
}

12.文件中有一组整数,要求排序后输出到另一个文件中 答案:

void Order(vector<int> &data) //起泡排序
{
int count = data.size() ;
int tag = false ;
for ( int i = 0 ; i < count ; i++)
{
for ( int j = 0 ; j < count - i - 1 ; j++)
{
if ( data[j] > data[j+1])
{
tag = true ;
int temp = data[j] ;
data[j] = data[j+1] ;
data[j+1] = temp ;
}
}
if ( !tag )
break ;
}
}
void main( void )
{
vector<int>data;
ifstream in("c:\\data.txt");
if ( !in)
{
cout<<"file error!";
exit(1);
}
int temp;
while (!in.eof())
{
in>>temp;
data.push_back(temp);
}
in.close();
Order(data);
ofstream out("c:\\result.txt");
if ( !out)
{
cout<<"file error!";
exit(1);
}
for ( i = 0 ; i < data.size() ; i++)
out<<data[i]<<" ";
out.close();
}

.用递归方式,非递归方式写函数将一个字符串反转

非递归方式:

char *reverse(char *str)
{
 int len = strlen(str);   char temp;
 for(int i=0; i<len/2; i++)
 {
  temp = *(str+i);
  *(str+i) = *(str+len-1-i);
  *(str+len-1-i) = temp;
 }
 return str;
}

递归方式:
函数原型:char *reverse(char *str);
实现:

char* reverse(char* str)
          {      int len = strlen(str); 
           if (len <= 1)
          {
                 return str;
           }
       char lastData = str[len-1];  // 保留最后一个字符
       str[len-1] = '\0'; 
       reverse(str+1);
       str[len-1] = str[0];
       str[0] = lastData;
        return str;
         }

2. 编程实现:找出两个字符串中最大公共子字符串,如"abccade",“dgcadde"的最大子串为"cad”

int GetCommon(char *s1, char *s2, char **r1, char **r2)
{
int len1 = strlen(s1);
int len2 = strlen(s2);
int maxlen = 0;
for(int i = 0; i < len1; i++)
{
   for(int j = 0; j < len2; j++)
   {
      if(s1[i] == s2[j])
      {
        int as = i, bs = j, count = 1;
        while(as + 1 < len1 && bs + 1 < len2 && s1[++as] == s2[++bs])
            count++;

        if(count > maxlen)
        {
           maxlen = count;
           *r1 = s1 + i;
           *r2 = s2 + j;
        }
      }
   }
}

11.写一个函数比较两个字符串str1和str2的大小,若相等返回0,若str1大于str2返回1,若str1小于str2返回-1

int strcmp ( const char * src,const char * dst)
{
int ret = 0 ;
while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
{
++src;
++dst;
}
if ( ret < 0 )
ret = -1 ;
else if ( ret > 0 )
ret = 1 ;
return( ret );
}

给定字符串A和B,输出A和B中的最大公共子串。

比如A=“aocdfe” B=“pmcdfa” 则输出"cdf"
*/

//Author: azhen
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

char *commanstring(char shortstring[], char longstring[])
{
int i, j;

char *substring=malloc(256);

if(strstr(longstring, shortstring)!=NULL) //如果……,那么返回shortstring
return shortstring; 

for(i=strlen(shortstring)-1;i>0; i--) //否则,开始循环计算
{
for(j=0; j<=strlen(shortstring)-i; j++){
memcpy(substring, &shortstring[j], i);
substring[i]='\0';
if(strstr(longstring, substring)!=NULL)
return substring;
}
}
return NULL;
}

main()
{
char *str1=malloc(256);
char *str2=malloc(256);
char *comman=NULL;
gets(str1);
gets(str2);

if(strlen(str1)>strlen(str2)) //将短的字符串放前面
comman=commanstring(str2, str1);
else
comman=commanstring(str1, str2);

printf("the longest comman string is: %s\n", comman);
}

输出结果为:

int main(void)
{        char a[30];
        char *b = (char *)malloc(20 * sizeof(char));
        printf("%d\n", sizeof(a));
        printf("%d\n", sizeof(b));
        printf("%d\n", sizeof(a[3]));
        printf("%d\n", sizeof(b+3));
        printf("%d\n", sizeof(*(b+4)));
        return 0 ;
}

30 4 1 4 1

求1000!的未尾有几个0(用素数相乘的方法来做,如72=22233);

求出1->1000里,能被5整除的数的个数n1,能被25整除的数的个数n2,能被125整除的数的个数n3,
能被625整除的数的个数n4.
1000!末尾的零的个数=n1+n2+n3+n4;

#include<stdio.h>
#define NUM 1000
int find5(int num){
int ret=0;
while(num%5==0){
num/=5;
ret++;
}
return ret;
}
int main(){
int result=0;
int i;
for(i=5;i<=NUM;i+=5)
{
result+=find5(i);
}
printf(" the total zero number is %d\n",result);
return 0;
}

d)请编写一个 C 函数,该函数将一个字符串逆序。

#include <string.h>
#include <stdio.h>
void exchange(char *str) 
{ 
   char tmp; 
   int len, i, j; 
   len = strlen(str); 
   for(i = 0, j = len-1; i != len/2; i++, j--) { 
      tmp = str[i]; 
      str[i] = str[j]; 
      str[j] = tmp; 
   } 
return; 
} 
main() 
{ 
   char str[100]; 
   scanf("%s", str); 
   exchange(str); 
   printf("%s\n", str); 
   return; 
}

e)请编写一个 C 函数,该函数在给定的内存区域搜索给定的字符,并返回该字符所在位置索引值。

int search(char *cpSource, int n, char ch)  //起始地址,搜索长度,目标字符
{   int i;
for(i=0; i<n && *(cpSource+i) != ch; ++i);
return i;
}

f)请编写一个 C 函数,该函数在一个字符串中找到可能的最长的子字符串,该字符串是由同一字符组成的。

int  ChildString(char*p)     //自己写
  {   
  Char *q=p;
int  stringlen=0, i=0,j=1,len=0,maxlen=1;   
while(*q!=’\0)          //不能用strlen,求得长度stringlen
{
  Stringlen++;
q++;
}
  while( i< Stringlen )   
  {   
	  if(*(p+i)==*(p+j)&&j< Stringlen)   
	  {   
		  len++;                    //统计子串长度
		  i++;
		  j++;   
	  }   
	  else   
	  {   
		  if(len>maxlen)           //统计最大子串长度
		  {   
			  maxlen=len+1;   
			  len=0;
		  }  	
		  else {
			  len=0;
		       }   
		       i++;
			   j++;
                   
	  }   
  }  
  return   maxlen;   
}

用宏定义写出swap(x,y)

#define SWAP(A,B) {A=AB;B=AB;A=A^B;}//注意是{}不是()
#define swap(a,b) a=a+b;b=a-b;a=a-b

4、字符串函数

(1).strcpy

char * strcpy(char * strDest,const char * strSrc) 
{ 
if ((strDest==NULL)||(strSrc==NULL))
printf"Invalid arguments"; 
char * strDestCopy=strDest; 
while (*strSrc!='"0')
*strDest++=*strSrc++;
return strDestCopy; 
} 

(2).strlen

int strlen(const char* src)
{ if (src==NULL) 
 printf"Invalid arguments"; 
 int len = 0;
 while(*src++ != '"0')
 len++;
 return len;
}

(3).递归实现字符反转函数reverse

#include<iostream> 
#include<string> 
void reverse(char *str, int len)
{ if(len==1) return;
 else
 { char temp;
   temp=*str;*str=*(str+len);*(str+len)=temp;
   reverse((str+1),(len-2));
   return;
 }
}

(4).实现英语单词反转函数

int main()
{
string strIn;
strIn="I am a student";
int end;
end=strlen(strIn)-1;
for(int i=strIn.length()-1;i>=0;i--)
{
if(strIn[i]==' ')
{
for(int j=i+1;j<=end;j++)
cout<<strIn[j];
cout<<' ';
end=i-1;
}

(5).实现strstr(): 找出字符串sub在字符串src的什么位置,如"34"在"12345"的3位置。

char *strstr(char *str,char *sub_str)
{        int i=0,j=0;
        while(str[i]!='"0')
	       {          if(str[i]==sub_str[j]) {
                       break;
                }
                else { i++; }
        }
            if(sub_str[i]!='"0')
               return (char *)(str+i);
             else return NULL;

}

3)写出在母串中查找子串出现次数的代码.

int count1(char* str,char* s)
{    char* s1;
    char* s2;
    int count = 0;
    while(*str!='\0')
    {    s1 = str;
        s2 = s;
        while(*s2 == *s1&&(*s2!='\0')&&(*s1!='0'))
        {  s2++;
            s1++;
        }
        if(*s2 == '\0')
            count++;
        str++;
    }
    return count;
}

4)写出快速排序或者某种排序算法代码
快速排序:

int partition(int* a,int l,int r)
{
    int i=l-1,j=r,v=a[r];
    while(1)
    {
        while(a[++i]<v);
        while(a[--j]>v) if(j<=i) break;
        if(i>=j)
            break;
        swap(a[i],a[j]);
    }
    swap(a[i],a[r]);
    return i;
}

void qsort(int* a,int l,int r)
{
    if(l>=r) return;
    int i = partition(a,l,r);
    qsort(a,l,i-1);
    qsort(a,i+1,r);
}

冒泡排序:

void buble(int *a,int n)
{
    for(int i=0;i<n;i++)
    {
        for(int j=1;j<n-i;j++)
        {
            if(a[j]<a[j-1])
            {
                int temp=a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
            }
        }
    }
}

插入排序:

void insertsort(int* a,int n)
{
    int key;
    for(int j=1;j<n;j++)
    {
        key = a[j];
        for(int i=j-1;i>=0&&a[i]>key;i--)
        {
            a[i+1] = a[i];
        }
        a[i+1] = key;
    }
}

1.什么是中断?中断发生时CPU做什么工作?

所谓中断是指系统发生某一事件后,CPU暂停正在执行的程序转去执行处理该事件的程序过程,处理中断事件的程序称为中断处理程序,产生中断信号的那个部件称为中断源。硬件的中断机构与处理这些中断的程序统称为中断系统。
当中断发生时,硬件机构自动地进入响应中断过程,由操作系统的中断处理程序对中断事件进行处理,具体过程如下:
①•保存现场
系统开辟现场区,并将现场区组织成"栈"结构,当中断响应时,(1)硬件结构自动将PS和PC寄存器的内容压人栈中作为现场信息保存起来。(2)根据发生的中断,硬件从指定的中断向量单元中取出PS和PC内容,分别装人PS和PC寄存器,同时正确填人路寄存器的"当前状态"和"先前状态"字段。
②•分析原因,转中断处理程序
不同原因产生的中断事件要进行不同的处理,根据中断的路寄存器内容得出发生该种中断的具体原因。转人相对应的申断处理程序运行。
③•恢复现场
在多级中断系统中,考虑退回当前中断时,必须依据原先被中断的程序,完成不同的工作,中断处理结柬后,软件必须退出中断。如果此次是高级中断,并且被中断的程序是一个低级中断处理程序,则此次中断应返回到该低级中断处理程序。如果原来被中断的是用户程序,则退出中断前应先考虑进行一次调度选择,以挑选出更适合在当前情况下运行的新程序。

2.CPU在上电后,进入操作系统的main()之前必须做什么工作?

整个系统对开发环境以及各种变量的初始化,包括了变量空间的分配,cpu内部寄存器的初始化,总线的初始化等等,总之,只有等系统初始化完成以后,我们的c语言的main才能被识别和执行下来

  1. 下面这段代码的输出是多少(在32位机上).
    char *p;
    char *q[20];
    char *m[20][20];
    int (*n)[10];
    struct MyStruct{
    char dda;
    double dda1;
    int type ;
    };
    MyStruct k;
    printf("%d %d %d %d",sizeof§,sizeof(q),sizeof(m),sizeof(n),sizeof(k));
    答案:4,80,1600,4,24 n是指向一维数组的指针变量;k中不要忘了考虑对齐问题,这里dda为4个字节。

1. 进程和线程的区别

主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间,一个进程崩溃后,在保护模式下不会对其它进程产生影响,而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量,但线程之间没有单独的地址空间,一个线程死掉就等于整个进程死掉,所以多进程的程序要比多线程的程序健壮,但在进程切换时,耗费资源较大,效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作,只能用线程,不能用进程。 ①进程:一个程序对一个数据集的动态执行过程,是分配资源的基本单位。 线程:一个进程内的基本调度单位。 ②进程:拥有独立的内存单元,而多线程共享内存,从而提高了应用程序的运行效率。 线程:每一个独立的线程,都有一个程序运行的入口、顺序执行序列和程序的出口,但是线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制③多线程的意义在于一个应用程序中,有多个执行部分可以同时执行。但是操作系统并没有将多个线程看作多个独立的应用来实现进程的调度和管理以及资源分配。

2.解释局部变量、全局变量和静态变量的含义。

局部变量包括函数的形参,包含在函数体或者语句块内的变量,局部变量的生存期在退出函数或语句块后结束。
全局变量是指在所有函数和语句块之外的变量,它对于整个程序均可见,全局变量的生存期与程序的生存期相同.
静态变量指由关键字static声明的变量,它的作用域和其他变量一样,由它所在的位置决定,如在函数体或语句块中声明,则只在函数体或语句块可见,其他地方均不可见.它的生存期与程序相同.

3.Windows程序的入口是哪里?写出Windows消息机制的流程。

Windows程序的入口是WinMain函数.消息机制:系统将会维护一个或多个消息队列,所有产生的消息都会被放入或是插入队列中。系统会在队列中取出每一条消息,根据消息的接收句柄而将该消息发送给拥有该窗口的程序的消息循环。每一个运行的程序都有自己的消息循环,在循环中得到属于自己的消息并根据接收窗口的句柄调用相应的窗口过程。而在没有消息时消息循环就将控制权交给系统。

6.C++里面如何声明const void f(void)函数为C程序中的库函数?

在该函数前添加extern “C”声明
extern修饰符可用于指示C或者C++函数的调用规范。比如在C++中调用C库函数,就需要在C++程序中用extern “C”声明要引用的函数(只有C++才有extern “C”的用法,在C中这样用会报错)。这是给链接器用的,告诉链接器在链接的时候用C函数规范来链接。主要原因是C++和C程序编译完成后在目标代码中命名规则不同。

7.下列哪两个是等同的

int b;
  A const int* a = &b;
  B const* int a = &b;
  C const int* const a = &b;
  D int const* const a = &b;
各式表示的意思分别为:
A const int* a = &b; //a是const,但指针a可变
B const
int a = &b; //a是const,但a可变
C const int
const a = &b; //a和a都是const,常量和指针的值都不能改变
D int const
const a = &b; //a和*a都是const,常量和指针的值都不能改变
因此C,D两者是相同的。
总结个技巧:如果const位于星号的左侧,则const就是用来修饰指针所指向的变量,即指针指向为常量;如果const位于星号的右侧,const就是修饰指针本身,即指针本身是常量。

下述三个有什么区别?
char * const p;
char const * p
const char *p
char * const p; //常量指针,p的值不可以修改
char const * p;//指向常量的指针,指向的常量值不可以改
const char *p; //同char const *p

1.请问以下代码有什么问题:

int main()
{ char a;
char *str=&a;
strcpy(str,“hello”);
printf(str);
return 0;
}
没有为str分配内存空间,将会发生异常。问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果,但因为越界进行内在读写而导致程序崩溃。

int (*s[10])(int) 表示的是什么
int (*s[10])(int) 函数指针数组,每个指针指向一个int func(int param)的函数。

1:(void )ptr 和 ((void**))ptr的结果是否相同?其中ptr为同一个指针.(void )ptr 和 ((void**))ptr值是相同的

char* s=“AAA”;
printf("%s",s);
s[0]=‘B’;
printf("%s",s);
有什么错?
"AAA"是字符串常量。s是指针,指向这个字符串常量,所以声明s的时候就有问题。
cosnt char* s=“AAA”;然后又因为是常量,所以对是s[0]的赋值操作是不合法的。

2,已知一个数组table,用一个宏定义,求出数据的元素个数

#define NTBL
#define NTBL (sizeof(table)/sizeof(table[0]))

1、找错

Void test1()
{
char string[10];
char* str1="0123456789";
strcpy(string, str1);// 溢出,应该包括一个存放'\0'的字符string[11]
}


Void test2()
{
char string[10], str1[10];
for(I=0; I<10;I++)
{
str1[i] ='a';
}
strcpy(string, str1);// I,i没有声明。
}

Void test3(char* str1)
{
char string[10];
if(strlen(str1)<=10)// 改成<10,字符溢出,将strlen改为sizeof也可以
{
strcpy(string, str1);
}
}

2.

void g(int**);
int main()
{
int line[10],i;
int *p=line; //p是地址的地址
for (i=0;i<10;i++)
{
*p=i;
g(&p);//数组对应的值加1
}
for(i=0;i<10;i++)
printf("%d\n",line[i]);
return 0;
}

void g(int**p)
{
(**p)++;
(*p)++;// 无效
}

输出:1 2 3 4 5 6 7 8 9 10

3. 写出程序运行结果

int sum(int a)
{ auto int c=0;
  static int b=3;
  c+=1;
  b+=2;
  return(a+b+c);
}
void main()
{  int I;
   int a=2;
   for(I=0;I<5;I++)
 {
   printf("%d,", sum(a));
  }
}// 考察static会保存上次结果

输出:8,10,12,14,16,

4.

int func(int a)
{ int b;
  switch(a)
 {
  case 1: 30;
   case 2: 20;
   case 3: 16;
   default: 0
 }
 return b;
}

则func(1)=?
// b定义后就没有赋值。

5:

int a[3];
a[0]=0; a[1]=1; a[2]=2;
int *p, *q;
p=a;
q=&a[2];

则a[q-p]=a[2]=2
解释:指针一次移动一个int但计数为1

试题8:请说出static和const关键字尽可能多的作用

解答:
  static关键字至少有下列n个作用:
  (1)函数体内static变量的作用范围为该函数体,不同于auto变量,该变量的内存只被分配一次,因此其值在下次调用时仍维持上次的值;
  (2)在模块内的static全局变量可以被模块内所用函数访问,但不能被模块外其它函数访问;
  (3)在模块内的static函数只可被这一模块内的其它函数调用,这个函数的使用范围被限制在声明它的模块内;
  (4)在类中的static成员变量属于整个类所拥有,对类的所有对象只有一份拷贝;
  (5)在类中的static成员函数属于整个类所拥有,这个函数不接收this指针,因而只能访问类的static成员变量。
  const关键字至少有下列n个作用:
  (1)欲阻止一个变量被改变,可以使用const关键字。在定义该const变量时,通常需要对它进行初始化,因为以后就没有机会再去改变它了;
  (2)对指针来说,可以指定指针本身为const,也可以指定指针所指的数据为const,或二者同时指定为const;
 (3)在一个函数声明中const可以修饰形参,表明它是一个输入参数,在函数内部不能改变其值;

14.函数assert的用法?

答:断言assert是仅在debug版本起作用的宏,用于检查“不应该“发生的情况。程序员可以把assert看成一个在任何系统状态下都可以安全使用的无害测试手段。assert()宏是用于保证满足某个特定条件,用法是:assert(表达式); 如果表达式的值为假,整个程序将退出,并输出一条错误信息。如果表达式的值为真则继续执行后面的语句。使用这个宏前需要包含头文件assert.h

15.为什么在头文件的最前面都会看到这样的代码:

#ifndef STDIO_H
#define STDIO_H
头文件中的#ifndef一般格式是这样的#ifndef <标识> ,#define <标识>;<标识>在理论上来说可以是自由命名的,但每个头文件的这个“标识”都应该是唯一的。标识的命名规则一般是头文件名全大写,前后加下划线,并把文件名中的“.”也变成下划线,如:stdio.h
#ifndef STDIO_H
#define STDIO_H

16.为什么数组名作为参数,会改变数组的内容,而其它类型如int却不会改变变量的值?

答:当数组名作为参数时,传递的实际上是地址。而其他类型如int作为参数时,由于函数参数值实质上是实参的一份拷贝,被调函数内部对形参的改变并不影响实参的值。

7)实现strcmp函数

int strcmp11(char* l,char* r)
{    assert(l!=0&&r!=0);
    while(*l == *r &&*l != '\0') l++,r++;
    if(*l > *r)
        return 1;
    else if(*l == *r)
        return 0;
    return -1;
}

//实现字符串翻转

void reserve(char* str)
{    assert(str != NULL);
    char * p1 = str;
    char * p2 = str-1;
    while(*++p2);         //一般要求不能使用strlen
    p2 -= 1;
    while(p1<p2)
    {        char c = *p1;
        *p1++ = *p2;
        *p2-- = c;
   }
}

10)将一个数字字符串转换为数字.“1234” -->1234

int atoii(char* s)
{    assert(s!=NULL);
    int num = 0;
    int temp;
    while(*s>'0' && *s<'9')
    {   num *= 10;
        num += *s-'0';
        s++;
    }
    return num;
}

11)实现任意长度的整数相加或者相乘功能。

void bigadd(char* num,char* str,int len)
{    for(int i=len;i>0;i--)
    {   num[i] += str[i];
        int j = i;
        while(num[j]>=10)
        {  num[j--] -= 10;
            num[j] += 1;
        }
    }
}

12)写函数完成内存的拷贝

void* memcpy( void *dst, const void *src, unsigned int len )
{   register char *d;
    register char *s;
    if (len == 0)
        return dst;
    if ( dst > src )   //考虑覆盖情况
    {
        d = (char *)dst + len - 1;
        s = (char *)src + len - 1;
        while ( len >= 4 )   //循环展开,提高执行效率
        {
            *d-- = *s--;
            *d-- = *s--;
            *d-- = *s--;
            *d-- = *s--;
            len -= 4;
        }
        while ( len-- ) 
        {
            *d-- = *s--;
        }
    } 
    else if ( dst < src ) 
    {
        d = (char *)dst;
        s = (char *)src;
        while ( len >= 4 )
        {
            *d++ = *s++;
            *d++ = *s++;
            *d++ = *s++;
            *d++ = *s++;
            len -= 4;
        }
        while ( len-- )
        {
            *d++ = *s++;
        }
    }
    return dst;
}

21、用指针的方法,将字符串“ABCD1234efgh”前后对调显示

    char str123[] = "ABCD1234efgh";
    char * p1 = str123;
    char * p2 = str123-1;
    while(*++p2);
    p2 -= 1;
    while(p1<p2)
    {
        char c = *p1;
        *p1++ = *p2;
        *p2-- = c;
}
  • 0
    点赞
  • 0
    评论
  • 9
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 博客之星2020 设计师:CY__ 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值