部分C库函数重写(经典c/c++面试题)

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

////////////////////////////////////////////////////

//Convert character to uppercase.

const char *toupper(char *s)

{

for(char *t=s;*t!='\0';t++)

{

if(*t>='a'&&*t<='z')

*t-='a'-'A';

}

return s;

}

////////////////////////////////////////////////////

//Copies characters between buffers.

//

// 函数说明: memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。

// 与strcpy()不同的是,memcpy()会完整的复制n个字节,不会因为遇到字符串结束'\0'而结束

// memcpy功能和memmove相同，但是memcpy中dest和source中的区域不能重叠，否则会出现未知结果。

//

// 返回值说明：返回指向dest的void *指针

// 附加说明: 指针src和dest所指的内存区域不可重叠

//

void *memcpy(void *dest, const void *src, size_t count)

{

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

char *tmp_dest = (char*)dest;

char *tmp_src = (char*)src;

while( count--)//不对是否存在重叠区域进行判断

*tmp_dest++ = *tmp_src++;

return dest;

}

////////////////////////////////////////////////////

//Moves one buffer to another.

//

// 函数说明：memmove用于从source拷贝count个字符到dest，如果目标区域和源区域有重叠的话，

// memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。

// 返回值说明：返回指向dest的void *指针

void *memmove(void *dest, const void *src, size_t count)

{

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

char *tmp_dest=(char*)dest;

char *tmp_src=(char*)src;

if( tmp_dest+count<tmp_src||tmp_src+count<tmp_dest )

{// 如果没有重叠区域

while(count--)

*tmp_dest++=*tmp_src;

}

else

{// 如果有重叠区域

tmp_dest+=count-1;

tmp_src+=count-1;

while(count--)

*--tmp_dest=*--tmp_src;

}

return dest;

}

////////////////////////////////////////////////////

//Sets buffers to a specified character.

void *memset(void *src, int c, size_t count)

{

assert(src!=NULL);

char *tmpsrc=(char*)src;

while(count--)

*tmpsrc++ =(char)c;

return src;

}

////////////////////////////////////////////////////

//Finds characters in a buffer.

void* memchr(const void* src, int c, size_t count)

{

assert(src!=NULL);

char *tempsrc=(char*)src;

while(count&&*tempsrc!=(char)c)

{

count--;

tempsrc++;

}

if(count!=0)

return tempsrc;

else

return NULL;

}

////////////////////////////////////////////////////

//Get the length of a string

int strlen(const char *str)

{

assert( str!=NULL );

int length = 0;

while( *str++!='\0' )

length++;

return length;

}

////////////////////////////////////////////////////

// Copy a string

/*void strcpy(char *strDest, const char *strSrc)

{

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

while( *strSrc!='\0' )

*strDest++ = *strSrc++;

*strDest = '\0';

}*/

// 标准库函数

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

{

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

char *address = strDest;

while( (*address++ = *strSrc++)!='\0' );

return address;

}

////////////////////////////////////////////////////

//Append a string

char *strcat(char *str1, const char *str2)

{

assert( (str1!=NULL)&&(str2!=NULL) );

while( *str1!='\0' )

str1++;

while( (*str1++ = *str2++)!='\0' );

return str1;

}

////////////////////////////////////////////////////

//Compare strings

int strcmp(const char *str1, const char *str2)

{

while( *str1!='\0' && *str2!='\0' && *str1==*str2 )

{

str1++;

str2++;

}

if( *str1 =='\0' )

{

if( *str2 =='\0' )

return 0;

else

return -1;

}

else if( *str2 =='\0' )

{

if( *str1 =='\0' )

return 0;

else

return 1;

}

else

{

if( *str1<*str2 )

return -1;

else

return 1;

}

}

////////////////////////////////////////////////////

//Find a character in a string.

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

{

while( *str!='\0' && *str!=(char)ch )

str++;

if( *str==(char)ch )

return (char*)str;

else

return NULL;

}

////////////////////////////////////////////////////

//Find a substring.

char *strstr(const char *src, const char *strCharSet)

{

char *tempStr=(char*)src;

while( (*tempStr++!=*strCharSet)!='\0' );

char *temp=--tempStr;

if( *tempStr=='\0' )

return NULL;

else

{

while(*tempStr==*strCharSet&&*tempStr!='\0'&&*strCharSet!='\0')

{

tempStr++;

strCharSet++;

}

if(*strCharSet=='\0')

return temp;

else

return NULL;

}

}

c/c++面试题集

1、 如何判断一个单链表是有环的？（注意不能用标志位，最多只能用两个额外指针）

struct node { char val; node* next;}

bool check(const node* head) {} //return false : 无环；true: 有环

一种O（n）的办法就是（搞两个指针，一个每次递增一步，一个每次递增两步，如果有环的话两者必然重合，反之亦然）：

bool check(const node* head)

{

if(head==NULL) return false;

node *low=head, *fast=head->next;

while(fast!=NULL && fast->next!=NULL)

{

low=low->next;

fast=fast->next->next;

if(low==fast) return true;

}

return false;

}

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 > maxnumber )

{

sec_max = maxnumber ;

maxnumber = data ;

}

else

{

if ( data > sec_max )

sec_max = data ;

}

}

return sec_max ;

}

3、 链表题：一个链表的结点结构

struct Node

{

int data ;

Node *next ;

};

typedef struct Node Node ;

(1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel)

Node * ReverseList(Node *head) //链表逆序

{

if ( head == NULL || head->next == NULL )

return head;

Node *p1 = head ;

Node *p2 = p1->next ;

Node *p3 = p2->next ;

p1->next = NULL ;

while ( p3 != NULL )

{

p2->next = p1 ;

p1 = p2 ;

p2 = p3 ;

p3 = p3->next ;

}

p2->next = p1 ;

head = p2 ;

return head ;

}

(2)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序。(保留所有结点，即便大小相同）

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 ;

}

(3)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序，这次要求用递归方法进行。 (Autodesk)

答案：

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 ;

}

4、 如何判断一段程序是由C 编译程序还是由C++编译程序编译的？

答案：

#ifdef __cplusplus

cout<<"c++";

#else

cout<<"c";

#endif

5、There are two int variables: a and b, don’t use “if”, “? :”, “switch”or other judgement statements, find out the biggest one of the two numbers.

答案：

( ( a + b ) + abs( a - b ) ) / 2

6、如何定义和实现一个类的成员函数为回调函数

A.什么是回调函数?

简而言之，回调函数就是被调用者回头调用调用者的函数。

使用回调函数实际上就是在调用某个函数（通常是API函数）时，将自己的一个函数（这个函数为回调函数）的地址作为参数传递给那个被调用函数。而该被调用函数在需要的时候，利用传递的地址调用回调函数。

回调函数，就是由你自己写的，你需要调用另外一个函数，而这个函数的其中一个参数，就是你的这个回调函数名。这样，系统在必要的时候，就会调用你写的回调函数，这样你就可以在回调函数里完成你要做的事。

B.如何定义和实现一个类的成员函数为回调函数

要定义和实现一个类的成员函数为回调函数需要做三件事：

a．声明；

b．定义；

c．设置触发条件，就是在你的函数中把你的回调函数名作为一个参数，以便系统调用

如：

一、声明回调函数类型

typedef void (*FunPtr)(void);

二、定义回调函数

class A

{

public:

A();

static void callBackFun(void) //回调函数，必须声明为static

{

cout<<"callBackFun"<<endl;

}

virtual ~A();

};

三、设置触发条件

void Funtype(FunPtr p)

{

p();

}

void main(void)

{

Funtype(A::callBackFun);

}

C. 回调函数与API函数

回调和API非常接近，他们的共性都是跨层调用的函数。但区别是API是低层提供给高层的调用，一般这个函数对高层都是已知的；而回调正好相反，他是高层提供给底层的调用，对于低层他是未知的，必须由高层进行安装，这个安装函数其实就是一个低层提供的API，安装后低层不知道这个回调的名字，但它通过一个函数指针来保存这个回调函数，在需要调用时，只需引用这个函数指针和相关的参数指针。

其实：回调就是该函数写在高层，低层通过一个函数指针保存这个函数，在某个事件的触发下，低层通过该函数指针调用高层那个函数。