01 赋值运算符重载的需求
有时候希望赋值运算符两边的类型可以不匹配,比如:把一个 int 类型变量赋值给一个Complex(复数)对象,或把一个 char* 类型的字符串赋值给一个字符串对象,此时就需要重载赋值运算符‘=’。
需要注意的是:赋值运算符 = 只能重载为成员函数。
02 赋值运算符重载的例子
下面我们以自定义一个自己的字符串类代码的例子,讲解赋值运算符的重载函数。
class MyString // 字符串类
{
public:
// 构造函数,默认初始化1个字节的字符
MyString ():m_str(new char[1])
{
m_str[0] = 0;
}
// 析构函数,释放资源
~MyString()
{
delete [] m_str;
}
const char* c_str()
{
return m_str;
}
// 赋值运算符重载函数
// 重载=号使得 obj = "Hello" 能够成立
MyString & operator= (const char *s)
{
// 释放旧字符串资源
delete [] m_str;
// 生成新字符串的空间大小,长度多+1的目的是存放\0
m_str = new char[strlen(s) +1 ];
// 拷贝新字符串的内容
strcpy(m_str, s);
// 返回该对象
return *this;
}
private:
char * m_str; // 字符串指针
};
int main() {
MyString s;
s = "Hello~"; // 等价于s.operator=("Hello~");
std::cout << s.c_str() << std::endl;
// MyString s2 = "Hello!"; // 这条语句要是不注释就会编译报错
s = "Hi~"; // 等价于s.operator=("Hi~");
std::cout << s.c_str() << std::endl;
return 0;
}
输出结果:
Hello~
Hi~
重载=号运算符函数后,s = "Hello~"; 语句就等价于 s.operator=("Hello~");。
需要注意的一点是:上面的MyString s2 = "Hello!";语句实际上是初始化语句,而不是赋值语句,因为是初始化语句,所以需要调用构造函数进行初始化,那么这时就需要有char*参数的构造函数,由于我们没有定义此构造函数,所以就会编译出错。
03 浅拷贝和深拷贝
还是依据上面的例子,假设我们要实现最后一个语句的方式:
MyString s1,s2;
s1 = "this"; // 调用重载的赋值语句
s2 = "that"; // 调用重载的赋值语句
s1 = s2; // 如何实现这个??
s1 = s2;语句目的希望是s1对象放的字符串和s2对象放的字符串象要一样,由于 = 号两边的类似都是对象,编译器会用原生的赋值运算符函数,但是这个原生的赋值运算符函数对于有指针成员变量的对象来说,是非常危险的!
浅拷贝
如果用原生的赋值运算符函数去赋值有指针成员变量的对象,就会使得两个对象的指针地址也是一样的,也就是两个对象的指针成员变量指向的地址是同一个地方,这种方式就是浅拷贝。
这时当一个对象释放了指针成员变量时,那么另外一个对象的指针成员变量指向的地址就是空的了,再次使用这个对象时,程序就会奔溃了,因为该对象的指针成员函数已经是个不合法的指针了!
深拷贝
如果对象里面有指针成员变量,则我们需要对原生的赋值运算符函数,防止出现程序出错现象的发生。
因此要在 class MyString 类里加上如下成员函数:
MyString & operator=(const MyString & s)
{
// 释放旧字符串资源
delete [] m_str;
// 生成新字符串的空间大小,长度多+1的目的是存放\0
m_str = new char[strlen(s.m_str) +1 ];
// 拷贝新字符串的内容
strcpy(m_str, s.m_str);
// 返回该对象
return *this;
}
这么做就够了吗?还有什么需要改进的地方吗?
我们在考虑下面的语句:
MyString s;
s = "Hello";
s = s; // 是否会有问题?
最后一个语句是否会有问题?
s = s;等价于s.operator=(s),由于s和s是相同的对象,那么就没必要完全执行重载的赋值 = 的函数了,我们再加个判断,当左右两边是相同对象时,就直接返回该对象就好:
MyString & operator=(const MyString & s)
{
// 当左右两边是相同对象时,就直接返回该对象就
if(this == &s)
return *this;
delete [] m_str;
m_str = new char[strlen(s.m_str) +1 ];
strcpy(m_str, s.m_str);
return *this;
}
对operator=返回值类型的讨论
当我们重载一个运算符的时候,好的风格应该是尽量保留运算符原本的特性
考虑:
分别等价于:
所以综上考虑,operator=返回值类型是MyString &是比较好的。
04 复制(拷贝)构造函数
上面的MyString类是否就没有问题了?
MyString s;
s = "Hello";
MyString s1(s); // 要考虑这种情况,那就要重载复制(拷贝)构造函数
如果使用默认的复制(拷贝)构造函数,那就对有指针成员变量的对象会有问题,因为会默认的复制(拷贝)构造函数会导致两个对象的指针成员变量指向同一个的空间。
所以需要对复制(拷贝)构造函数重载,并实现深拷贝的方式:
MyString (const MyString &s)
{
m_str = new char[strlen(s.m_str) + 1];
strcpy(m_str, s.m_str);
}
05 小结
最后的所有代码,如下:
class MyString // 字符串类
{
public:
// 构造函数,默认初始化1个字节的字符
MyString ():m_str(new char[1])
{
m_str[0] = 0;
}
// 复制(拷贝)构造函数
MyString (const MyString &s)
{
m_str = new char[strlen(s.m_str) + 1];
strcpy(m_str, s.m_str);
}
// 析构函数,释放资源
~MyString()
{
delete [] m_str;
}
const char* c_str()
{
return m_str;
}
// 赋值运算符重载函数
// 重载=号使得 obj = "Hello" 能够成立
MyString & operator= (const char *s)
{
// 释放旧字符串资源
delete [] m_str;
// 生成新字符串的空间大小,长度多+1的目的是存放\0
m_str = new char[strlen(s) +1 ];
// 拷贝新字符串的内容
strcpy(m_str, s);
// 返回该对象
return *this;
}
// 赋值运算符重载函数
// 重载=号使得 obj1 = obj2 能够成立
MyString & operator=(const MyString & s)
{
// 当左右两边是相同对象时,就直接返回该对象就
if(this == &s)
return *this;
delete [] m_str;
m_str = new char[strlen(s.m_str) +1 ];
strcpy(m_str, s.m_str);
return *this;
}
private:
char * m_str; // 字符串指针
};
int main()
{
MyString s1,s2;
s1 = "Hello~"; // 等价于s1.operator=("Hello~");
std::cout << s1.c_str() << std::endl;
s2 = "Hi~"; // 等价于s2.operator=("Hi~");
std::cout << s2.c_str() << std::endl;
s1 = s2; // 等价于s1.operator=(s2);
std::cout << s1.c_str() << std::endl;
MyString s3(s1); // 复制构造函数
std::cout << s3.c_str() << std::endl;
return 0;
}
输出如下:
Hello~
Hi~
Hi~
Hi~
C语言浮点数存储方式
C语言浮点数存储方式
一. 浮点数内存存储方式
对于浮点类型的数据采用单精度类型(float)和双精度类型(double)来存储,float数据占用 32bit,double数据占用 64bit.其实不论是float类型还是double类型,在计算机内存中的存储方式都是遵从IEEE的规范的,float 遵从的是IEEE R32.24 ,而double 遵从的是R64.53。
无论是单精度还是双精度,在内存存储中都分为3个部分:
1) 符号位(Sign):0代表正,1代表为负;
2) 指数位(Exponent):用于存储科学计数法中的指数数据,并且采用移位存储;
3) 尾数部分(Mantissa):尾数部分
其中float的存储方式如下图所示:
而双精度的存储方式为:
R32.24和R64.53的存储方式都是用科学计数法来存储数据的
用二进制的科学计数法第一位都是1嘛,干嘛还要表示呀?可以将小数点前面的1省略,所以23bit的尾数部分,可以表示的精度却变成了 24bit,道理就是在这里。
那24bit能精确到小数点后几位呢,我们知道9的二进制表示为1001,所以4bit能精确十进制中的1位小数 点,24bit就能使float能精确到小数点后6位,而对于指数部分,因为指数可正可负,8位的指数位能表示的指数范围就应该为:-127-128了, 所以指数部分的存储采用移位存储,存储的数据为元数据+127。
二. 十进制小数转换为二进制小数
十进制小数转换成二进制小数采用"乘2取整,顺序排列"法。具体做法是:用2乘十进制小数,可以得到积,将积的整数部分取出,再用2乘余下的小数部分,又得到一个积,再将积的整数部分取出,如此进行,直到积中的小数部分为零,或者达到所要求的精度为止。 然后把取出的整数部分按顺序排列起来,先取的整数作为二进制小数的高位有效位,后取的整数作为低位有效位。
【例1】把(0.8125)转换为二进制小数。
解:
【例2】(173.8125)10=( )2
解:(173)10=(10101101)2
由[例1]得(0.8125)10=(0.1101)2
把整数部分和小数部分合并得: (173.8125)10=(10101101.1101)2
下面就看看8.25和120.5在内存中真正的存储方式:
首先看下8.25,用二进制的科学计数法表示为 ,首先(8.25)10 = (1000.01)2=(1.00001*2^3)
=1.00001*2^3 按照上面的存储方式,符号位为0,表示为正;指数位为3+127=130,位数部分为 1.00001,故8.25的存储方式如下: 0x41040000 = 0100 0001 0000 0100 0000 0000 0000 0000
分解如下:0--10000010--00001000000000000000000
符号位为0,指数部分为10000010,位数部分为 00001000000000000000000
同理,120.5在内存中的存储格式如下: (120.5)10 = (01111000.1)2=(1.1110001*2^6)
=1.1110001*2^6 按照上面的存储方式,符号位为0,表示为正;指数位为6+127=133,位数部分为 1.1110001,故120.5的存储方式如下: 0x41040000 = 0100 0010 1111 0001 0000 0000 0000 0000
0x42f10000: 0100 0010 1111 0001 0000 0000 0000 0000
分解如下:0--10000101--11100010000000000000000
三. 二进制小数转换为十进制小数
由二进制小数转换成十进制小数的基本做法是,把二进制数首先写成加权系数展开式,然后按十进制加法规则求和。这种做法称为"按权相加"法。
例1把二进制小数110.11转换成十进制小数。
那么如果给出内存中一段数据,并且告诉你是单精度存储的话,你如何知道该数据的十进制数值呢?其实就是对上面的反推过程,比如给出如下内存数据: 01000001001000100000000000000000
第一步:符号位为0,表示是正数;
第二步:指数位为10000010,换算成十进制为130,所以指数为130-127=3;
第三步:尾数位为01000100000000000000000,
第四步:二进制表示为:1.01000100000000000000000因为指数为+3(右移3),-3(左移位3)所以也等价于
1010.00100000000000000000 = 10.00100000000000000000=10+(0/2+0/4+1/8)=10.125
【同例1】:换算成十进制为 (1+1/4+1/64); 所以相应的十进制数值为:2^3*(1+1/4+1/64)=8+2+1/8=10.125
浮点数(double、float)如何定义NaN、正无穷、负无穷,以及如何判断是否是NaN
一. 原理
NaN :指数位的每个二进制位全为1 并且尾数不为0;
无穷 :指数位的每个二进制位全为1并且尾数为0;符号位为0,是正无穷,符号位为1是负无穷。
所以NaN、正无穷、负无穷可以如此定义,可以如此判断是否NaN:
二. 判断方法
static inline bool isInf(double d)
uchar *ch = (uchar *)&d;
if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
return (ch[0] & 0x7f) == 0x7f && ch[1] == 0xf0;
} else {
return (ch[7] & 0x7f) == 0x7f && ch[6] == 0xf0;
static inline bool isNan(double d)
uchar *ch = (uchar *)&d;
if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
return (ch[0] & 0x7f) == 0x7f && ch[1] > 0xf0;
} else {
return (ch[7] & 0x7f) == 0x7f && ch[6] > 0xf0;
static inline bool isFinite(double d)
uchar *ch = (uchar *)&d;
if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
return (ch[0] & 0x7f) != 0x7f || (ch[1] & 0xf0) != 0xf0;
} else {
return (ch[7] & 0x7f) != 0x7f || (ch[6] & 0xf0) != 0xf0;
static inline bool isInf(float d)
uchar *ch = (uchar *)&d;
if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
return (ch[0] & 0x7f) == 0x7f && ch[1] == 0x80;
} else {
return (ch[3] & 0x7f) == 0x7f && ch[2] == 0x80;
static inline bool isNan(float d)
uchar *ch = (uchar *)&d;
if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
return (ch[0] & 0x7f) == 0x7f && ch[1] > 0x80;
} else {
return (ch[3] & 0x7f) == 0x7f && ch[2] > 0x80;
static inline bool isFinite(float d)
uchar *ch = (uchar *)&d;
if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
return (ch[0] & 0x7f) != 0x7f || (ch[1] & 0x80) != 0x80;
} else {
return (ch[3] & 0x7f) != 0x7f || (ch[2] & 0x80) != 0x80;