C++博客-5D空间-随笔分类-学习笔记

C++中对浮点数的格式化显示

今晚打老虎 — Tue, 31 May 2011 03:38:00 GMT

以下是转帖内容：
--------------------------------------------------------------------------------------------------------------------------------------------------------------
第二电脑网导读：框、关系数据库、金融程序、SMS程序及一切处理数据文件的程序，需要控制小数点后的小数位的情况非常普遍，本文中将要讲解如何用简单的方法来控制小数位，另外，还要揭开字符串及数据精度的一点点小秘密。　　问题的引出　　如有一个函数，其可接受一个long double参数，并将参数转换为字符串，结果字符串应保留两位小数，例如，浮点值123.45678应该生成"123.45"这样的...

正文：在许多应用程序领域中，都需要控制小数点后的小数位，但是浮点数对此不能提供直接的支持。怎样对程序中的浮点数据进行"整齐"地格式化呢？在此我们有一个迂回的方法，先把它们转换为字符串，格式化后以文本形式显示出来。

　　在日常编程中--包括对话框、关系数据库、金融程序、SMS程序及一切处理数据文件的程序，需要控制小数点后的小数位的情况非常普遍，本文中将要讲解如何用简单的方法来控制小数位，另外，还要揭开字符串及数据精度的一点点小秘密。

　　问题的引出

　　如有一个函数，其可接受一个long double参数，并将参数转换为字符串，结果字符串应保留两位小数，例如，浮点值123.45678应该生成"123.45"这样的字符串。表面上看来这是一个意义不大的编程问题，然而，如果真要在实际中派上用场，函数应设计为具有一定弹性，以允许调用者指定小数位数。另外，函数也应该能够处理各种异常情况，如像123.0或123这样的整数。
在开始之前，先看一下编写"优雅"C++代码时的两句"真言"：

　　"真言"1：无论何时需要格式化一个数值，都应先转换为一个字符串。这样可保证每位数刚好占据一个字符。

　　"真言"2：在需要转换为字符串时，请使用库。

　　转换函数的接口非常简洁：第一个参数是需被格式化的数值；第二个参数代表小数点后显示的小数位，且应该具有一个默认值；返回值为一个string类型：

string do_fraction(long double value, int decplaces=3);

　　注意，第二个参数代表的小数位数中包括了小数点，因此，两位小数需要默认值为3。

　　精度问题

　　当然，第一步是把long double值转换为一个string，使用标准C++库简直是手到擒来。然而，有一件事情必须引起注意，因为某些原因，stringstream对象默认精度为6，而许多程序员错误地把"精度"理解为小数的位数，这是不正确的，精度应指代全部位数。因而，数字1234.56可安全地通过默认精度6来表示，但12345.67会被截断为12345.6。这样的话，如果你有一个非常大的数，如1234567.8，它的结果会静悄悄地转换为科学记数法：1.23457e+06，这显然不是我们想要的。为避免这样的麻烦，在开始转换之前，应把默认精度设为最大。
为得到long double能表示的最大位数，可使用库：

string do_fraction(long double value, int decplaces=3)
{
int prec=numeric_limits::digits10; // 18
ostringstream out;
out.precision(prec);//覆盖默认精度
out<string str= out.str(); //从流中取出字符串数值现在存储在str中，等待格式化。

　　小数点的位置

　　要进行格式化，首先要确定小数点的位置，如果小数位多于decplaces，do_fraction()会删除多余的。

　　要定位小数位，可使用string::find()，在STL算法中使用了一个常量来代表"数值未找到"，在字符串中，这个常量为string::npos：

char DECIMAL_POINT='.'; // 欧洲用法为','

size_t n=str.find(DECIMAL_POINT);
if ((n!=string::npos)//是否有小数点呢？
{
//检查小数的位数
}

　　如果没有小数点，函数直接返回字符串，否则，函数将继续检查小数位是否多于decplaces。如果是，小数部分将会被截断：

size_t n=str.find(DECIMAL_POINT);
if ((n!=string::npos)//有小数点吗？
&&(str.size()> n+decplaces)) //后面至少还有decplaces位吗？

//在小数decplaces位之后写入nul
str[n+decplaces]='';

　　最后一行覆盖了多余的小数位，它使用了常量来截断字符串，要注意，string对象的数据可以包含nul字符；而字符串的实际长度由size()的返回值决定。因此，你不能假定字符串已被正确地格式化，换句话来说，如果在str中原来为"123.4567"，在插入常量之后，它变成了"123.457"，为把str缩减为"123.45"，一般可使用自交换的方法： str.swap(string(str.c_str()) );//删除nul之后的多余字符

　　那它的原理是什么呢？函数string::c_str()返回一个const char *代表此字符串对象，而这个值被用作一个临时string对象的初始化值，接着，临时对象又被用作str.swap()的参数，swap()会把值"123.45"赋给str。一些老一点的编译器不支持默认模板参数，可能不会让swap()通过编译，如果是这样的话，使用手工交换来代替：

string temp=str.c_str();
str=temp;

　　代码虽不是很"优美"，但能达到目的就行。以下是do_fraction()的完整代码：

string do_fraction(long double value, int decplaces=3)
{
　ostringstream out;
　int prec=
　numeric_limits::digits10; // 18

　out.precision(prec);//覆盖默认精度
　out<　string str= out.str(); //从流中取出字符串
　size_t n=str.find(DECIMAL_POINT);
　if ((n!=string::npos) //有小数点吗？
　&& (str.size()> n+decplaces)) //后面至少还有decplaces位吗？
　{
　　str[n+decplaces]='';//覆盖第一个多余的数
　}

　str.swap(string(str.c_str()));//删除nul之后的多余字符

　return str;
}

　　如果不想通过传值返回一个string对象，还可增加一个参数，把str对象以引用传递：

void do_fraction(long double value, string & str, int decplaces=3);

　　从个人的角度来讲，还是倾向于让编译器做这样的优化，另外，使用传值返回，还可以让你以下面这种方式使用do_fraction()：

cout << funct(123456789.69999001) << 't' << funct(12.011)<

　　输出：

　　123456789.69 12.01
--------------------------------------------------------------------------------------------------------------------------------------------------------------
先简单理清一下思路：
1 将double以最大精度保存在ss里
2 通过小数点来检测实际精度是否超过需要的精度
3 如果超过，截断
4 返回字符串

补充一下，第3步应该加一个四舍五入功能。这个比较简单，按相应的位数+5后再截断就好了

今晚打老虎 2011-05-31 11:38 发表评论

类型转换操作符

今晚打老虎 — Sun, 10 Apr 2011 15:12:00 GMT

　　有一类特殊的操作符重载，没有返回类型，这就是类型转换操作符
operator typename() const
{
return ...//...是typename类型的
}

　　可以这样来理解。转换构造函数是为了将一个其他类型转换到当前类型，重载类型转换操作符则是为了将当前类型转换到其他类型。

注意二义性
比如：

class Test
{
   Test();
   Test( int n );
   operator int();

   int value;
};

int main()
{
   Test myObject;
   Test yourObject;
   int intObject = 33;

   myObject = intObject;//可以通过
   myObject = yourObject + 3;//不可以通过。编译器不知道该调用(int)将yourObject转化为int还是调用Test( int )将3转化为Test
｝

今晚打老虎 2011-04-10 23:12 发表评论

VS2010实用小记

今晚打老虎 — Wed, 06 Apr 2011 06:50:00 GMT

1 快捷键
Ctrl + k + c 注释选中代码
Ctrl + k + u 取消选中代码注释

Ctrl + k + f 格式化选中代码
Ctrl + ←or→ 向左或右移动一个单词
Ctrl + w 选择当前单词
(按住Shift可以在移动中选择)

Ctrl + c/x 如果光标在这一行，则复制/剪贴整行
Ctrl + + l 删除当前行

Ctrl + m + o 所有大纲折叠
Ctrl + m + l 所有大纲展开

Ctrl + j 智能感知(写长代码时很好用)

Ctrl + tab 切换活动文件(还可以用Ctrl + F6，效果有点不一样)

今晚打老虎 2011-04-06 14:50 发表评论

关于二重模板小记1

今晚打老虎 — Tue, 05 Apr 2011 05:50:00 GMT

摘要：二重模板有什么用，什么情况下使用二重模板，对二重模板进行的某种特化进行重载，＝以及拷贝构造函数在二重模板中的注意事项
　　
　　小记1是因为这个话题很可能还有其他小记。
　　在模板下定义一个类，类的方法包括重载的运算符往往可以处理这个类模板对于相同类型参数的特化的对象。但是有时候我们往往希望一个类模板的特化对象的方法还可以处理这个类模板其他特化的对象。一种办法是利用类的性质定义转换构造函数（convert constructor ），但是我们可以使用模板得到一种更通用的方法，那就是在类模板中定义二重模板。
　　定义方法很简单，下面的例子会展示。注意内层模板的参数应该与外层模板不一样，而且定义的时候应该使用两层template。
　　对于一般的函数和运算符，通常来说，如果只定义一个二重模板的方法，它既可以处理不同类型的特化对象，也可以处理相同类型的特化对象（即T和C是相同类型）。如果在外层模板中另外定义了一个普通的同名方法（以处理相同类型的特化对象），那么在处理相同类型的特化对象时，则会调用这一套方法。这有点像对模板特化进行重载（告诉编译器在特殊情况，这里是特化类型相同，应该使用另外一套方法）。
例如：
如果把8行和14~18行注释掉，那么输出结果均为两行接受不同类型。

1#include <iostream>
2using namespace std;
3
4template < typename T >
5class A
6{
7public:
8    void function( const A< T > & );
9
10    template < typename C >
11    void function( const A< C > & );
12};
13
14template < typename T >
15void A< T >::function( const A< T > & )
16{
17    cout << "接受相同类型" << endl;
18}
19
20template < typename T >
21template < typename C >
22void A< T >::function( const A< C > & )
23{
24    cout << "接受不相同类型" << endl;
25}
26
27int main()
28{
29    A< int > a;
30    A< int > b;
31    A< double > c;
32
33    a.function( b );
34    a.function( c );
35}

　　但是对于复制操作符和拷贝构造函数来说，情况有些不一样。因为编译器会为没有定义的类提供默认＝以及拷贝构造函数，根据上面的分析，这个默认的东西相当于对二重模板中特殊情况的重载，所以如果只有一个二重模板，那么它将不能处理相同类型的类模板特化的对象。而这时，程序会调用编译器提供的默认＝以及拷贝构造函数，而这往往是我们不想要的（我们需要自己定制的＝以及拷贝构造函数啊）。所以这时，我们需要自己定制一套非二重模板的＝或者拷贝构造函数来满足需求。

例如：
如果把8行和14~18行注释掉，那么输出结果只有一行为不同类型调用=号，因为另外一句话调用了编译器提供的默认=号，所以并没有任何输出。

1#include <iostream>
2using namespace std;
3
4template < typename T >
5class B
6{
7public:
8    void operator=( const B< T > & );
9
10    template < typename C >
11    void operator=( const B< C > & );
12};
13
14template < typename T >
15void B< T >::operator=( const B< T > & )
16{
17    cout << "为相同类型调用=号" << endl;
18}
19
20template < typename T >
21template < typename C >
22void B< T >::operator=( const B< C > & )
23{
24    cout << "为不同类型调用=号" << endl;
25}
26
27int main()
28{
29    B< int > a;
30    B< int > b;
31    B< double > c;
32
33    a = b;
34    a = c;
35}

今晚打老虎 2011-04-05 13:50 发表评论

模板的声明与实现的分离方法

今晚打老虎 — Mon, 04 Apr 2011 18:01:00 GMT

　　c++标准定义了export来实现模板的声明与实现的分离。很遗憾，现在很多编译器没有支持，包括我现在使用的vs2010。
　　有一些其他的方法。这里介绍一种。

　　首先，在.h文件中声明模板，并在最后包含相应的cpp文件。然后将实现写在cpp文件中。乍一看很别扭，仔细一想其实是合情合理的。不是要求声明和定义在一起，且声明出现在定义之前么，这样写，.h文件就符合要求了。

类模板声明

//This is MyClass.h

#include <iostream>
using namespace std;

template< typename T >
class MyClass
{
public:
T function( const T & );
};

#include "Myclass.cpp"

类模板定义

//This is MyClass.cpp

template< typename T >
T MyClass< T >::function( const T &ref )
{
   cout << "this is my class" << endl;
   return ref;
}

int MyClass< int >::function( const int &ref )
{
   cout << "this is int class" << endl;
   return ref;
}

　　
　　这里cpp文件中顺便演示了一下如何重载特定类型的模板特化。

今晚打老虎 2011-04-05 02:01 发表评论

多重继承、二义性、虚基类（虚继承）之我见

今晚打老虎 — Mon, 04 Apr 2011 09:24:00 GMT

　　在学习多重继承、二义性、虚基类的时候遇到了一些困惑。经过一定的学习摸索，虽然在底层机制上还不太清楚，但是在抽象层面上有了一定理解。
　　书上只有一个虚基类的概念，即在继承的时候加上关键字virtual。这里我们姑且把这种继承方式叫做虚继承。现在先来说一下虚继承和一般继承的区别。
　　要解释这一系列问题，我们首先要搞清楚这一系列概念意味着什么。多重继承不用赘述。现在先就二义性和虚继承谈谈我的看法。

　　在一般的继承中（非虚继承），每一个派生类都保存了一份完整的基类副本。考虑以下继承：

class A
{
   void print();
};

class B : public A
{
   void print();
};

class C : public C
{
   void print();
};

在这样一系列继承体系中，A包含一份print()，B包含了两份，而C则包含了三分prin()。这里总共有6份独立的print()函数。虽然在C中调用B::print()感觉和B中调用print()效果一样，但他们确实是作为两个副本存在。　　而在虚继承中，考虑如下继承：

class A
{
   void print();
};

class B : virtual public A
{
   void print();
};

class C : virtual public C
{
   void print();
};

Ｂ只含有一份print()副本，但是却可以通过A::print()调用A的print()函数。同理，C也只包含了一份print()副本。这里总共只有3分print()副本。虚继承中基类的数据并没有变多一份给派生类，而只是使用权移交了，就好像A有一栋楼，虚继承给B，名义上Ｂ也拥有了这栋楼，可以使用，但是并没有真正为Ｂ另外建一栋一模一样的楼。

　　二义性：要解释二义性，最好先定义一个概念：名字间隔。笼统地表达，一个名字的间隔就是某个数据的名字从继承层次中首次出现到达最后派生类时中间隔了多少相同的名字。间隔越少，这个名字的优先级越高。当然直接在最终类里面声明的名字具有最高的优先级。比如考虑一开始的普通继承：

class A
{
   void print();
};

class B : public A
{
   void print();
};

class C : public C
{
   void print();
};

如果使用Ｃ的对象，那么A中的pirnt与C间隔最大，C中的print与C的间隔最短，所以如果直接调用C对象的print函数，那么将调用C版本的print。如果C没有定义一个print函数，那么B中的print函数与C间隔最小，那么调用C对象的print函数时，将调用B版本的print函数。
　　有了这个概念，现在来解释二义性：如果存在两个及其以上的名字距离最终派生类的距离最短（长度一样），那么，根据刚才由名字间隔定义的优先级别，在直接调用这个派生类对象的相应数据时，便不知道该调用哪个版本了（注意直接两个字，因为可以通过二元::来分辨具体的版本以调用，所以即使名字存在二义性，如果未调用这些名字，编译器可能不会报错）。有两种情况（到目前为止我看到的）可能导致二义性：1、在类中声明了两个名字一样的成员：这是最糟糕的情况，因为如果这样做了，没有办法弥补，但这也是最好的情况，因为编译器根本不会让你这么做。2、多继承的时候继承了两个间隔一样的名字：通常难以对付的是这种情况。
　　关于上述第二种情况（多继承），这些具有二义性的名字可能1、来自两个基类各自的声明，2、也可能来自两个基类继承自更高层次的同一基类（菱形继承），3、也可能其中一个名字来自基类声明，另一个名字来自另一个基类对更高层次基类的继承。无论如何，只要同时存在两个及其以上具有如果存在两个及其以上的名字距离最终派生类的距离最短（长度一样），那么就存在二义性。
例
1、来自两个基类各自声明

class B1
{
void print();
};

class B2 :
{
void print();
};

class C : public B1, public B2
{
};

2、菱形继承

class A
{
void print();
};

class B1 : public A
{
};

class B2 : public A
{
};

class C : public B1, public B2
{
};

3、其中一个名字来自基类声明，另一个名字来自另一个基类对更高层次基类的继承

class A
{
void print();
};

class B1 : public A
{
};

class B2 :
{
void print();
};

class C : public B1, public B2
{
};

（注意：虽然A版本的print是通过B1到达C的，但是A->B1->C的过程中，A版本的print与C之间并没有间隔其他的print，这与B2版本的print一样，所以他们具有相同的名字间隔，因此具有二义性）

　　二义性的解决办法：
　　1、在最终派生类中定义一个相同名字的成员，这样这个名字距离最终派生类最近，所以就会调用这个名字下的数据（通常教材里叫做这个名字把其他名字隐藏了）。这个名字（如果是函数）你可以自己定义新的方法，也可以通过二元::调用你已知的存在二义性的名字中的某一个（注意：如果你选择的调用版本不是该派生类的直接基类，那么该如何调用呢？比如A->B->C，那么从C的对象c调用A的print函数，c.A::print()是否可行？我在vs2010上，虽然报错但是编译通过且正常运行。如果各位有任何见解或建议，希望不吝赐教。）
　　2、使用虚继承（针对菱形继承等）：回想一下虚继承和普通继承，通过虚继承的方法可以消除重复副本带来的二义性问题。比如在某一继承层次上，这个某两个名字具有二义性，然而顺着继承层次向上分析，却发现这两个名字其实是同一个东西的两个副本，这个时候如果使用虚继承，那么就使得这两个副本变为一个副本（准确地说，两个副本都没有了，因为只存在他们公共基类的那份数据，虚基类得到的不过是使用权）。

写在后面：
　　注意虚函数和虚继承的区别：虚函数并没有减少任何数据的存在，仅仅相当于在基类指针层面上建立了一种“调用最靠近对象类型的函数”的机制。然而虚继承则是一种类的继承方式，即，只创建派生类特有部分的数据，继承的数据按需从基类索取。所以虽然他们都是用virtual关键字，但似乎意思上联系不大。
　　另外，是用虚继承能够解决的问题相当有限。而且虚继承面临一个开销问题，虽然从继承层面上看，这是一个消除二义性的好方法，而且似乎对编程没有什么副作用。这个道理与虚函数带来的好处与开销权衡问题差不多。一些书希望把这个问题留个程序员自己权衡，一些书则建议一律使用虚函数。不过应该指出，现在硬件设备能力的提升速度似乎在不断削弱我们对开销问题的顾忌（只要算法上不存在问题），所以即使你不打算从现在开始就全盘使用虚函数以及虚继承（而且对于一般的小程序，即使不断加上这些关键字也会使人厌烦吧，况且有些类似乎一辈子也不会成为基类呢？），但是请至少保持这样一个念头，多一种打算，多一条路嘛。

今晚打老虎 2011-04-04 17:24 发表评论

类实例化时默认构造函数调用小记

今晚打老虎 — Sun, 03 Apr 2011 19:04:00 GMT

class A
{
public:
    A( int a = 10 )
    {
        c = a;
    }

    int c;
};

int main()
{
    A t1;
    A t2();
    A *p1 = new A;
    A *p2 = new A();
}

　　四种实例化类的方法（调用默认构造函数）。其中第二种是错误的，编译器认为是这样一个函数的声明。

今晚打老虎 2011-04-04 03:04 发表评论

关于类模板的友元函数

今晚打老虎 — Thu, 31 Mar 2011 11:15:00 GMT

　　对类建立友元函数很容易。但是迁移到模板上却容易出现让人摸不着头脑的连接错误。
　　层次不够，不做分析，单纯介绍两种为类模板定义友元函数的方法

　　１　封闭型

template< typename T >
class MyClass
{
    friend void function( MyClass< T > &arg )
    {

    }
};

　　要点：友元函数定义在模板体内。

２　开放型

template< typename T >
class MyClass
{
    template< typename C >
    friend void function( MyClass< C > &arg );
};

template< typename C >
void function( MyClass< C > &arg )
{

}

　　要点：模板体内要另建模板。
　　
　　3 告诉编译器声明的设个是模板

#include <iostream>
using namespace std;

template < typename T >
class A
{
    friend ostream &operator<< < T >( ostream &, const A< T > & );
};

template < typename T >
ostream &operator<< ( ostream &output, const A< T > &a )
{
    output << "重载成功" << endl;
    return output;
}

int main()
{
    A< int > a;
    cout << a;
}

要点：显示地在重载的运算符或者函数后面加上模板声明< T >，告诉编译器友元函数是一个类型一致的模板。

建议：
            如果希望使用函数与模板特化的类型相对应，则使用方法3（模板显示声明）
            如果希望使用函数与模板特化的类型相独立，则使用方法2（二重模板）
            简短的内联函数使用方法1

今晚打老虎 2011-03-31 19:15 发表评论

关于运算符重载的一些笔记

今晚打老虎 — Thu, 31 Mar 2011 11:07:00 GMT

1.先 += 再 +。利用+=在+中操作副本。
2.只需要制定一套该类之间的运算符重载和一套该类与其他类型的转换构造函数即可实现该类与其他类型之间的运算符重载。
3.+ - * /返回副本
a++ 返回延迟副本
关系运算符返回bool

其他值运算符（= += ++a等）返回引用（特别注意：不是常量引用。发现编译器支持（a = b ）= c 这种语法。说明带=运算符返回为引用。且逻辑上也说得通）

4. !=
{
return !( a == b );
}
5.+ - * /及关系运算符不改变对象的值，应该加const
6.对于+等双向操作符，应该定义为全局函数以实现交换律（考虑到利用+=来简化操作并创建副本，可以一个参数接受副本，另一个参数接受常量引用）
7.利用<和==足够实现其他关系运算符

今晚打老虎 2011-03-31 19:07 发表评论

最简短的鹦鹉学舌程序

今晚打老虎 — Sat, 26 Mar 2011 18:21:00 GMT

　　自我感觉是最简短的写法了，由此可以引出重要的思想（直接流操作）以及流函数rdbuf的相关内容。请自行查阅。

#include <iostream>
using namespace std;

int main()
{
cout << cin.rdbuf();
}

今晚打老虎 2011-03-27 02:21 发表评论