4.已知String类的原型是:
class String
{
public:
String(const char* str = NULL); //普通的构造函数
String(const String& that); //拷贝构造函数
～String(void);//析构函数
String& operator=(const String& that);//赋值函数
const char* c_str(void) const；//完成和C的字符串兼容;
private:
char* m_str;
};
#include <iostream>
#include <cstring>
using namespace std;
class String
{
public:
/*一个简写的String(const char* str == NULL)
{
m_str(strcpy((new char[strlen(str?str:"")+1]),str?str:""));
}
*/
String(const char* str = NULL)
{
if(str == NULL)
{
m_str = new char[];
*m_str = '\0';
}
else
{
int length = strlen(str);
m_str = new char[length+];
strcpy(m_str,str);
}
}
~String(void)
{
if(m_str)
{
delete[] m_str;
m_str = NULL;
}
}
/*拷贝构造函数*/ /*简单版本String(const String& that):m_str
(strcpy(new char[strlen(that.str)+1],that.m_str))
*/
String(const String& that)
{
m_str = new char[strlen(that.m_str) + ];
strcpy(m_str,that.m_str);
}
/*简单版本的赋值运算符函数
String& operator=(const String& that)
{
if(&that != this)
{
String& tmep(that);
swap(m_str,tmp.m_str);
}
return *this;
}
*/
String& operator=(const String& that)
{
//检查自赋值
if(this == &that)
return *this;
//释放原有的内存资源
delete[] m_str;
//分配新的内存资源,并复制内容
m_str = new char[strlen(that.m_str + )];
strcpy(m_str,that.m_str);
//返回本对象的引用
return *this;
}
//保证向C语言字符串的兼容
const char* c_str(void) const
{
return m_str;
}
private:
char* m_str;
};
int main(void)
{
String s1 = "Hello,World!";
String s2 = s1;
cout << s1.c_str()<< endl;
cout << s2.c_str()<< endl;
String s3("hello,C++!");
s2 = s3;
cout << s1.c_str() << endl;
cout << s2.c_str() << endl;
}
当写一个赋值运算符函数的时候,它会考察你下面几个方面的内容;
1)是否把返回值类型声明为该类型的引用,并在函数结束前返回实例自身的引用(即*this).只有返回一个引用,才可以
允许连续赋值.
2)是否把传入的参数的类型声明为常量引用.如果传入的参数不是引用而是实例对象,那么从行参到实参会调用
一次复制构造函数.把参数声明为引用可以避免这样的无谓的消耗,能提高代码的效率.同时,我们在赋值运算符
函数内不会改变传入的实例的状态,因此应该传入的引用参数加上const关键字.
3)是否释放实例自身已有的内存,如果我们忘记在分配新内存之前释放自身已有的空间.程序将内存泄漏.
4)是否判断传入的参数和当前的实例(*this)是不是同一个实例.如果是同一个,则不进行操作直接返回.
如果事先不判断就进行赋值,那么释放实例自身的内存的时候就会导致严重的问题;当*this和传入的参数是
同一个实例时,那么一番释放了自身的内存,传入参数的内存也同时被释放了,因此再也找不到需要赋值的
内容了.
5.联合以及大小端模式:分析下段代码的打印结果?已知采用的是大端模式;
#include <stdio.h>
union
{
int i;
char x[];
} a;
void main(void)
{
a.x[] = ;//0000 1010 低位低地址
a.x[] = ;//0000 0001 高位高地址
a.x[] = ;
a.x[] = ;
printf("%#0x",a.i); //0000 0000 0000 0000 0000 0001 0000 1010
}
分析:大端模式：低字节高地址；小端模式：低字节低地址;
而数组的首地址是低地址的,由于是大端模式,所以a.x[0]实际上是i的高位,值为a;
所以打印结果是0xa010000;
如果是小端模式的话:a.x[0]实际上是i的低位,值为a;
这个时候打印结果就是0x10a;
6>写一个判断函数,来判断系统是大端模式还是小端模式?
#include <stdio.h>
int checkSystem(void)
{
union check
{
int i;
char ch;
}check;
check.i = ;
return (check.ch == );
}
int main(void)
{
int flag = ;
flag = checkSystem();
if(!flag)
{
printf("系统是大端模式!\n");
}
else
printf("系统是小端模式!\n");
return ;
}
运用char和int的联合来判断,让i=1,如果这个时候取ch的值为1的话
就证明是小端模式,因为联合取的时候肯定取的低位,而低8位的值肯定是1
如果ch的值不是1就证明它是大端模式,其实这个时候它的结果是0;
7.关于strlen和sizeof的区别?
1.sizeof是一个运算符,而strlen是一个库函数,需要包含头文件<string.h>
2.sizeof的参数可以数据类型或变量,而strlen的参数只能是一个以'\0'结束
的字符串.这里注意如果是字符串或字符数组里面有0字符的时候,它计算
的是到第一个字符0为止的长度,并且不包括'\0'或字符0;
3.编译器在编译的时候就计算出了sizeof()的结果,而strlen函数必须是在运行
的时候才计算出来.并且sizeof加算的是数据类型或数组所占用的内存的字节数,
而strlen计算的是一个字符串到遇到0字符或'\0'的长度.
4.当sizeof以数组名当参数的时候,不会退化.而数组名作为strlen
的参数的时候会退化为一个字符指针,指向的是字符串的首地址.
看下面的打印结果?
#include <stdio.h>
#include <string.h>
/*strlen在计算数组的长度的时候遇到0就会停止计算它的长度*/
int main(void)
{
char arr[] = {,,,,,};
printf("sizeof(arr) = %d,strlen(arr) = %d\n",sizeof(arr),strlen(arr));
return ;
}
这里的sizeof(arr) = 7没有疑问？唯一的疑点是strlen(arr)的值结果不是6而是2;
而如果写成 strlen("10111")的结果依然是5,从而可以得出结论是strlen只有在计算
字符数组的时候才会把字符0当成是'\0',而在字符串中好像不是.
再看一下下面的例子?这个例子也是典型的strlen(str)的例子.
#include <stdio.h>
#include <string.h> int main(void)
{
char buf[];
int i = ;
for(i = ;i < ;i++)
{
buf[i] = - - i;
printf("%d ",buf[i]);
}
printf("\n");
printf("%d\n",strlen(buf));
return ;
}
求buf的长度,这里的buf[0] = -1;
当i = 127的时候buf[127] = -128; 而无符号的字符的取值范围是-128 到 127;
所以 buf[127 + 128] = 0;即是当i = 255的时候,buf[255] = 0;即是字符0
所以字符串的长度是0-254即是255；