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[1]; *m_str = ‘\0‘; } else { int length = strlen(str); m_str = new char[length+1]; 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) + 1]; 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 + 1)]; 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[4]; } a; void main(void) { a.x[0] = 10;//0000 1010 低位低地址 a.x[1] = 1;//0000 0001 高位高地址 a.x[2] = 0; a.x[3] = 0; 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 = 1; return (check.ch == 1); } int main(void) { int flag = 0; flag = checkSystem(); if(!flag) { printf("系统是大端模式!\n"); } else printf("系统是小端模式!\n"); return 0; }
运用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[] = {1,2,0,3,4,0}; printf("sizeof(arr) = %d,strlen(arr) = %d\n",sizeof(arr),strlen(arr)); return 0; }
这里的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[1000]; int i = 0; for(i = 0;i < 1000;i++) { buf[i] = -1 - i; printf("%d ",buf[i]); } printf("\n"); printf("%d\n",strlen(buf)); return 0; }
求buf的长度,这里的buf[0] = -1;
当i = 127的时候buf[127] = -128; 而无符号的字符的取值范围是-128 到 127;
所以 buf[127 + 128] = 0;即是当i = 255的时候,buf[255] = 0;即是字符0
所以字符串的长度是0-254即是255；