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 发表评论

PointerPool(指针池)

今晚打老虎 — Mon, 11 Apr 2011 08:13:00 GMT

摘要: 对象池的指针版本。池中本质上是一群对象，只构造一次，返回指针。主要支持频繁重建的内存空间不连续的自建结构，如树，链表。 /**//****************************************************************** *名称:PointerPool(指针池)(模板) *版本号:0.1 *作者:赵耀(中山大学2010级)&... 阅读全文

今晚打老虎 2011-04-11 16:13 发表评论

类型转换操作符

今晚打老虎 — 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 发表评论

LHRODT(非递归求解度数为2的线性齐次方程的第n项）

今晚打老虎 — Mon, 04 Apr 2011 06:40:00 GMT

　　如题，利用非递归办法解决a(n) = r1*a(n-1) + r2*a(n-2)问题。其中斐波那契数列即为r1 = r2 = a1 = a2 = 1的特例。
　　函数支持两种版本的调用，一种是完全版，一种是简洁版。完全版需要５个参数r1 r2 a1 a2 n，简洁版只需要一个参数n。具体使用方法见代码注释。

/*********************************************************************************
*名称:LHRODT.h
*版本号:0.1
*作者:赵耀(中山大学2010级)
*时间:2011.4.4
*简介:
*        linear homogeneous relation of degree two的计算函数.形如:
*            a(n) = r1*a(n-1) + r2*a(n-2)
*    这样的递归数列，只需调用函数
*            LHRODT( r1, r2, a1, a2, n )
*    即可返回数列的第a(n)项(r1,r2,a1,a2均为double类型,n为int类型,返回类型为double).
*    这里r1,r2为公式中r1,r2,而a1,a2为数列的头两项,n为第几项.函数带缓存功能,即第一次
*    调用后,下次调用可以只输入
*            LHRODT( n )
*    .
*
*未完成特性:
*    1.不含有数据检测功能,如果输入的数据无解,则会返回0.
*    2.简洁版的调用不包含条件检测机制,如果不满足条件依然会调用,但是返回0.
*    3.未含有范围检测功能，如果数据函数结果增长很快，有可能出现数据溢出而没有任何提示.
*已知bug:
*    1.无法处理无解数据的输入.
*    2.简洁版在未调用完全版或者完全版调用失败的情况下只返回0.
*    3.可能在没有任何提示的情况下出现数据溢出.
*版权信息:
*        该代码为开源代码,原作者保留其所有权.你可以拷贝,修改,使用该代码,但是请保留必
*    要的版权信息.
*********************************************************************************/

#ifndef LHRODT_H
#define LHRODT_H
#include <cmath>
using std::pow;

class fsLHRODT //fs = function support
{
public:
    fsLHRODT();
    double operator()( double, double, double, double, int );
    double operator()( int );

private:
    double x1; //x1 x2 u1 u2 det 均为计算过程的中间变量
    double x2; //result 为最后结果的临时储存
    double u1;
    double u2;
    double det;
    double result;
    bool flag; //标记完全版的函数是否被调用过
};

fsLHRODT::fsLHRODT()
    : x1( 0 ), x2( 0 ), u1( 0 ), u2( 0 ), det( 0 ), result( 0 ), flag( false )
{
}

double fsLHRODT::operator()( double r1, double r2, double a1, double a2, int n )
{
    flag = true;
    det = r1*r1 + 4*r2;

    if ( det < 0 ) //det小于0说明输入的数据不合法,不能按照公式计算,并且下次不能直接调用简洁版函数
    {
        flag = false;
        return 0;
    }
    else if ( det > 0 )
    {
        det = sqrt( det );
        x1 = ( r1 + det ) / 2;
        x2 = ( r1 - det ) / 2;
        u1 = ( a1*x2 - a2 ) / ( x1*( x2 - x1 ) );
        u2 = ( a2*x1 - a1 ) / ( x2*( x1 - x2 ) );
        result = u1*pow( x1, n ) + u2*pow( x2, n );
        return result;
    }
    else
    {
        x1 = r1 / 2;
        u2 = ( a2 - x1*a1 ) / x1*x1;
        u1 = a1 / x1 - u2;
        result = ( u1 + u2*n ) * pow( x1, n );
        return result;
    }
}

double fsLHRODT::operator()( int n )
{
    if ( flag )
    {
        if ( det < 0 )
            return 0;
        else if ( det > 0 )
        {
            result = u1*pow( x1, n ) + u2*pow( x2, n );
            return result;
        }
        else
        {
            result = ( u1 + u2*n ) * pow( x1, n );
            return result;
        }
    }
    else
        return 0;
}

fsLHRODT LHRODT;

#endif

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

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

今晚打老虎 — 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 发表评论

probability(概率发生器)

今晚打老虎 — Sun, 03 Apr 2011 11:56:00 GMT

　　只有一个double参数，以百分比的形式给出发生概率。则函数每次调用按照这个概率返回true。
　　提示：函数内部会调用srand( time( 0 ) )。特别情况下需谨慎。

#ifndef PROBABILITY_H
#define PROBABILITY_H

#include <cstdlib>
#include <iostream>
#include <ctime>
using namespace std;

bool probability( double p ) //大概能精确到小数点后一位
{
    double happeness;
    static bool flag = false;

    if ( flag == false )
    {
        srand( time( NULL ) );
        flag = true;
    }

    /*
    happeness = rand() % 10001;
    happeness /= 100;
    这样的运算得到的值概率是不满足题意的。
    所以rand() % 这样的运算其实并没有实现真正的公平随机。
    */

    happeness = rand();
    happeness /= RAND_MAX;
    happeness *= 100;

    return ( happeness <= p );
}

#endif

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

findAnWithDegreeOfTwo(计算度数为2的齐次递归数列的第n项)

今晚打老虎 — Sun, 03 Apr 2011 11:53:00 GMT

　　递归数列a(n) = r1*a(n-1) + r2*a(n-2)
　　其中r1 r2是常数，a1 a2已知，按照顺序a1 a2 r1 r2 n输入参数，则返回这样一个递归数列的第n项值。类型均为double

#ifndef FINDAN_H
#define FINDAN_H

#include <cmath>

// a(n) = r1*a(n-1) + r2*a(n-2), give the a1, a2, r1, r2 and n
double findAnWithDegreeOfTwo( double a1, double a2, double r1, double r2, int n )
{
    double x1;
    double x2;
    double u1;
    double u2;
    double det = r1*r1 + 4*r2;
    double result;

    if ( det < 0 )
        return 0;
    else if ( det > 0 )
    {
        det = sqrt( det );
        x1 = ( r1 + det ) / 2;
        x2 = ( r1 - det ) / 2;
        u1 = ( a1*x2 - a2 ) / ( x1*( x2 - x1 ) );
        u2 = ( a2*x1 - a1 ) / ( x2*( x1 - x2 ) );
        result = u1*pow( x1, n ) + u2*pow( x2, n );
        return result;
    }
    else
    {
        x1 = r1 / 2;
        u2 = ( a2 - x1*a1 ) / x1*x1;
        u1 = a1 / x1 - u2;
        result = ( u1 + u2*n ) * pow( x1, n );
        return result;
    }
}

#endif

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

Zeller(计算某一天是星期几）

今晚打老虎 — Sun, 03 Apr 2011 11:47:00 GMT

　　输入三个参数分别表示年、月、日，返回一个int数字，代表这一天是星期几。计算过程采用蔡勒公式。

#ifndef ZELLER_H
#define ZELLER_H

int Zeller( int y, int m, int d )
{
    int c;

    if ( m <= 2 )
    {
        m += 12;
        y--;
    }

    c = y / 100;
    y %= 100;

    int w = ( y+(y/4)+(c/4)-2*c+(26*(m+1)/10)+d-1 ) % 7;
    if ( w <= 0 )
        w += 7;

    return w;
}

#endif

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

【求助】如何在继承中隐藏基类的某些公共接口？

今晚打老虎 — Sat, 02 Apr 2011 08:11:00 GMT

　　比如派生类是基类的一个限制版本，只能使用基类的某些public function。

今晚打老虎 2011-04-02 16:11 发表评论

【求助】如何限制模板接受的类型？

今晚打老虎 — Sat, 02 Apr 2011 08:08:00 GMT

　　如何限制模板特化需要接收的类型参数？比如我有个模板只能特化为和，而不能特化为类型？
　　老师提出了一个参考：通过异常机制。但是还没有具体思考如何实现。

今晚打老虎 2011-04-02 16:08 发表评论

关于类模板的友元函数

今晚打老虎 — 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 发表评论