1.写出完整版的strcpy函数
如果编写一个标准strcpy函数的总分值为10,下面给出几个不同得分的答案:
2分
void strcpy( char *strDest, char *strSrc )
{
while( (*strDest++ = * strSrc++) != ‘\0’ );
}
4分
void strcpy( char *strDest, const char *strSrc )
//将源字符串加const,表明其为输入参数,加2分
{
while( (*strDest++ = * strSrc++) != ‘\0’ );
}
7分
void strcpy(char *strDest, const char *strSrc)
{
//对源地址和目的地址加非0断言,加3分
assert( (strDest != NULL) && (strSrc != NULL) );
while( (*strDest++ = * strSrc++) != ‘\0’ );
}
10分
//为了实现链式操作,将目的地址返回,加3分!
char * strcpy( char *strDest, const char *strSrc )
{
assert( (strDest != NULL) && (strSrc != NULL) );
char *address = strDest;
while( (*strDest++ = * strSrc++) != ‘\0’ );
return address;
}
2.编写一个函数,作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”如果n=2,移位后应该是“hiabcdefg” 函数头是这样的:
//pStr是指向以’\0’结尾的字符串的指针
//steps是要求移动的n
void LoopMove(char *str, int steps)
{
int len = strlen(str);
char tmp[MAXSIZE];
memcpy(tmp, str+len-steps, steps);
memcpy(str+steps, str, len-steps);
memcpy(str, tmp, len);
}
memcpy(目标地址, 源地址, 拷贝的长度)。
例如 pStr=“123456”,steps=2,那么 len=6,st=2。
第一个 memcpy 中,pStr+len-st=“56”,st=2 所以就是把 “56” 这两个字符拷贝给 temp,temp=“56” 两个字符,即 temp[0]=‘5’,temp[1]=‘6’。
第二个 memcpy 中,temp+st=temp[2] 所在的地址,pStr=“123456”,len-st=4,也就是说把 pStr 的前 4 个字符拷贝到从 temp[2] 开始的地址里,即 temp[2]=‘1’,temp[3]=‘2’,temp[4]=‘3’,temp[5]=‘4’,即 temp=“561234” 六个字符。
第三个 memcpy 就是把 temp 里面的 6 个字符拷贝到从 pStr 起的连续 6 个 char 空间里头,因为第 7 个空间里至始至终都没有人动过,所以第 7 个空间里头还有 ‘\0’,所以 pStr=“561234” 字符串。这样就能实现循环右移了。
3.编写类String的构造函数、析构函数和赋值函数,已知类String的原型为:
class String
{
public:
String(const char *str = NULL); // 普通构造函数
String(const String &other); // 拷贝构造函数
~ String(void); // 析构函数
String & operator =(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];
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];
strcpy(m_data, other.m_data);
}
//赋值函数
String & String::operator =(const String &other) // 得分点:输入参数为const型
{
if(this == &other) //得分点:检查自赋值
return *this;
delete [] m_data; //得分点:释放原有的内存资源
int length = strlen( other.m_data );
m_data = new char[length+1];
strcpy( m_data, other.m_data );
return *this; //得分点:返回本对象的引用
}
4.下面代码会出现什么问题?
char *GetMemory( void )
{
char p[] = "hello world";
return p;
}
void Test( void )
{
char *str = NULL;
str = GetMemory();
printf( str );
}
char p[]=“hello world”;相当于char p[12],strcpy(p," hello world" ).p是一个数组名,属于局部变量,存储在栈中, " hello world" 存储在文字存储区,数组p中存储的是 " hello world" 的一个副本,当函数结束,p被回收,副本也消失了(确切的说p指向的栈存储区被取消标记,可能随时被系统修改),而函数返回的p指向的内容也变得不确定,文字存储区的 " hello world" 未改变。
可以这样修改:
①char* p= " hello world" ; return p; 这里p直接指向文字存储区的 " hello world" ,函数按值返回p存储的地址,所以有效。
②static char p[]= " hello world" ; return p; static指出数组p为静态数组,函数结束也不会释放,所以有效。
5.为什么标准头文件都有类似以下的结构?
#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern "C" {
#endif
/*...*/
#ifdef __cplusplus
}
#endif
#endif /* __INCvxWorksh */
作为一种面向对象的语言,C++支持函数重载,而过程式语言C则不支持。函数被C++编译后在symbol库中的名字与C语言的不同。
例如,假设某个函数的原型为:
void foo(int x, int y);
该函数被C编译器编译后在symbol库中的名字为_foo,而C++编译器则会产生像_foo_int_int之类的名字。_foo_int_int这样的名字包含了函数名和函数参数数量及类型信息,C++就是靠这种机制来实现函数重载的。
为了实现C和C++的混合编程,C++提供了C连接交换指定符号extern "C"来解决名字匹配问题,函数声明前加上extern "C"后,则编译器就会按照C语言的方式将该函数编译为_foo,这样C语言中就可以调用C++的函数了。
6.请说出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可以修饰形参,表明它是一个输入参数,在函数内部不能改变其值;
(4)对于类的成员函数,若指定其为const类型,则表明其是一个常函数,不能修改类的 成员变量;
(5)对于类的成员函数,有时候必须指定其返回值为const类型,以使得其返回值不为“左值”。
例如:
const classA operator*(const classA& a1,const classA& a2);
operator的返回结果必须是一个const对象。如果不是,这样的变态代码也不会编译出错:
classA a, b, c;
(a * b) = c; // 对ab的结果赋值
操作(a * b) = c显然不符合编程者的初衷,也没有任何意义。