C语言笔试题-4

第一题、字符串逆序

void reserve(char *str)
{
 int len = strlen(str);
 int i;
 char tmp;

 for (i = 0; i < len/2 + 1; i++)
 {
  tmp = str[i];
  str[i] = str[len-i-1];
  str[len-i-1] = tmp;
 }
}

 

第二题、

写出在母串中查找子串出现次数的代码.
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;
}

第三题、链表逆序

linklist *reserve(linklist *head)

{

    linklist *p , *q, *temp;

    p=head;  
    q=p->next;  
    while(q!=NULL)  
    {  
      temp=q->next;  
      q->next=p;  
      p=q;  
      q=temp;   
    }

 

   return p;

}  

 

第四题、将一个数字字符串转换为数字."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;
}
出现次数相当频繁

 

第五题、内存拷贝函数

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;
}

 

第六题、

编写类String的构造函数、析构函数和赋值函数，已知类String的原型为：

class String
{     
public:     
String(const char *str = NULL); // 普通构造函数   
String(const String &other); // 拷贝构造函数  
~ String(void); // 析构函数
String & operate =(const String &other); // 赋值函数     
private:    
char *m_data; // 用于保存字符串     
};

解答：
//普通构造函数
String::String(const char *str)
{
       if(str==NULL)
       {
               m_data = new char[1]; // 得分点：对空字符串自动申请存放结束标志'\0'的空
                                  　//加分点：对m_data加NULL 判断
              *m_data = '\0';
       }   
       else
       {
        int length = strlen(str);
        m_data = new char[length+1]; // 若能加 NULL 判断则更好
        strcpy(m_data, str);
       }
}
// String的析构函数
String::~String(void)
{
       delete [] m_data; // 或delete m_data;
}
//拷贝构造函数
String::String(const String &other) 　　　// 得分点：输入参数为const型
{    
       int length = strlen(other.m_data);
       m_data = new char[length+1]; 　　　　//加分点：对m_data加NULL 判断
       strcpy(m_data, other.m_data);   
}

//赋值函数
String & String::operate =(const String &other) // 得分点：输入参数为const型
{    
       if(this == &other)                 　　//得分点：检查自赋值
               return *this;  
       delete [] m_data;           　　　　//得分点：释放原有的内存资源
       int length = strlen( other.m_data );     
       m_data = new char[length+1]; 　//加分点：对m_data加NULL 判断
       strcpy( m_data, other.m_data );  
       return *this;    　　　　　　　　//得分点：返回本对象的引用
}