C++知识点总结(6)

1.double和float的存储方式

      float遵从的是IEEE R32.24 ,而double 遵从的是R64.53。无论是单精度还是双精度在存储中都分为三个部分：

1. 符号位(Sign) : 0代表正，1代表为负
2. 指数位（Exponent）:用于存储科学计数法中的指数数据，并且采用移位存储
3. 尾数部分（Mantissa）：尾数部分

         在计算机存储中，首先将数更改为二进制的科学计数法表示，8.25用二进制表示可表示为1000.01。120.5用二进制表示为：1110110.1用二进制的科学计数法表1000.01可以表示为1.0001*,1110110.1可以表示为1.1101101*。存储时，默认小数点前始终为1，但是1不存储。

           float.23bit。尾数部分，相当于可以表示的位数为24Bit，因此可以表示小数点后6位。同时，8位指数位要求表示-127----128范围的指数，因此总共可以表示256个指数。偏置量为1023。

          double.。类似float。指数表示-1023----1024个指数。尾数部分可以到小数点后13位。偏置量为1023。

             注意，由于涉及到负数存储。因此对于指数部分，float是+127，double是+2047后才存储的。

因此：(1)在单精度转换为双精度的时候，存在误差的问题，对于能够用二进制表示的十进制数据，如2.25，这个误差就会不存在。

         (2)0的单精度表示为0 0 0 0(1.0* 2^（-127）)而-0的单精度表示为 -128 0 0 0(-1.0*2^（-127）)。即表示存在误差。

<span style="font-size:18px;">float a = 1.0f;  
cout<< (int)a <<endl;  
cout<< (int&)a <<endl;  
cout << boolalpha << ( (int)a==(int&)a ) << endl; // false  
  
float b = 0.0f;  
cout<< (int)b <<endl;  
cout<< (int&)b <<endl;  
cout << boolalpha << ( (int)b==(int&)b ) << endl; // true </span>

2.C++构造函数的嵌套调用

class CLS  
{  
public:
	static int i;
	int m_i;
	static int j;
	 CLS(int t): m_i(t) {
	 }  
    CLS()  
    {  
        CLS(100); 
    }
	~CLS(){
	}
}; 

    调用1次构造函数相当于生成一个临时对象。此时该对象的m_i被赋值100，调用完后析构了此对象，但是当前的m_i实际没有初始化。

3.vector中的越界问题

int main(void)  
{  
    vector array;  
  
    array.push_back( 1 );  
    array.push_back( 2 );  
    array.push_back( 3 );  
    for( vector::size_type i=array.size()-1; i>=0; --i )    // 反向遍历array数组  
    {  
        cout << array[i] << endl;  
    }  
    return 0;  
} 

       size_type默认为无符号unsigned int 整型，当至最小数0-1，则产生的值为最大的数。

4.字符数组的初始化方法

char input[100];
cin.get(input,number,ch);//number表示最多读取的字符，ch表示遇到此字符则截止(默认为'
')，但是截止符号仍然存在于输入流中
cin.getline(input,number,ch);//同上，唯一不同的是，遇到截止符，截止符号被从输入流中删除。
gets(input);//输入的时候以换行符作为结束，空格键和制表符正常写入。由于此函数不会检查是否溢出，程序员必须保证。

5.qsort和sort的用法总结

qsort

原型:
_CRTIMP void __cdecl qsort (void*, size_t, size_t,int (*)(const void*, const void*));

解释:    qsort ( 数组名 ，元素个数，元素占用的空间(sizeof)，比较函数) 
比较函数是一个自己写的函数  遵循 int com(const void *a,const void *b) 的格式。
当a b关系为 >  <  = 时，分别返回正值 负值 零 （或者相反）。
使用a b 时要强制转换类型，从void * 转换回应有的类型后，进行操作。 

封装的是快速排序。

int num[100];  
int cmp ( const void *a , const void *b )//int  
{  
   return *(int *)a - *(int *)b;  
}  
qsort(num,100,sizeof(num[0]),cmp);  
  
char word[100];  
int cmp( const void *a , const void *b )//char  
{  
    return *(char *)a - *(int *)b;  
}  
qsort(word,100,sizeof(word[0]),cmp);  
  
double in[100];  
int cmp( const void *a , const void *b )//double  
{  
   return *(double *)a > *(double *)b ? 1 : -1;  
}  
qsort(in,100,sizeof(in[0]),cmp)；  
  
  
struct In  
{  
   double data;  
    int other;  
}s[100]  
int cmp( const void *a ,const void *b)//结构体一级  
{  
  return ((In *)a)->data > ((In *)b)->data ? 1 : -1;  
}  
qsort(s,100,sizeof(s[0]),cmp);  
  
  
struct In  
{  
  int x;  
   int y;  
}s[100];  
int cmp( const void *a , const void *b )//结构体二级  
{  
  In *c = (In *)a;  
  In *d = (In *)b;  
  if(c->x != d->x) return c->x - d->x;  
  else return d->y - c->y;  
}  
qsort(s,100,sizeof(s[0]),cmp);  
  
struct In  
{  
  int data;  
  char str[100];  
}s[100];  
int cmp ( const void *a , const void *b )//结构体按字符串排序  
{  
  return strcmp( ((In *)a)->str , ((In *)b)->str );  
}  
  
qsort(s,100,sizeof(s[0]),cmp);  

sort

       但是注意到，functional提供了一堆基于模板的比较函数对象：equal_to<Type>、not_equal_to<Type>、greater<Type>、greater_equal<Type>、less<Type>、less_equal<Type>。可以直接拿来用。

• 升序：sort(begin,end,less<data-type>());
• 降序：sort(begin,end,greater<data-type>())

int a[]={2,4,1,23,5,76,0,43,24,65};
double b[]={2.0,4.1,1.2,23.0,5.7,76.23,0.0,43.78,24.14,65.45};
vector<int> vec(a,a+sizeof(a)/sizeof(int));
list<int> List(a,a+sizeof(a)/sizeof(int));

sort(a,a+sizeof(a)/sizeof(int));//升序
sort(a,a+sizeof(a)/sizeof(int),compare1);//降序
sort(a,a+sizeof(a)/sizeof(int),greater<int>());//降序

sort(b,b+sizeof(b)/sizeof(double));//升序
sort(b,b+sizeof(b)/sizeof(double),greater<double>());//降序
sort(b,b+sizeof(b)/sizeof(double),compare2);//降序

sort(vec.begin(),vec.end(),less<int>());//升序
sort(List.begin(),List.end(),greater<int>());//降序

     其中，使用的自定义函数compare1和compare2分别为：

bool compare1(int a,int  b)
{
      return a>b; //降序排列
}
bool compare2(double a,double  b)
{
      return a>b?true:false; //降序排列
}

7.成员函数指针

class A{
private:
	int data;
public:
	A(int i=0):data(i){}
	string equal(const A& m){
		if(m.data==data)
			return "true";
		else
			return "false";
	}
};

int main()
{
	A a1(8),a2(4);
	string (A::*p)(const A&);
	p=&(A::equal);
	cout<<(a1.*p)(a2)<<endl;
	return 0;
}