| Profilo di 七夜Fly With The WindFotoBlogElenchi |  Strumenti  Guida |
|
|
29 aprile CString与int、char*、char[100]之间的转换CString互转int 将字符转换为整数，可以使用atoi、_atoi64或atol。 而将数字转换为CString变量，可以使用CString的Format函数。如 CString s; int i = 64; s.Format("%d", i) Format函数的功能很强，值得你研究一下。 void CStrDlg::OnButton1() { // TODO: Add your control notification handler code here CString ss="1212.12"; int temp=atoi(ss); CString aa; aa.Format("%d",temp); AfxMessageBox("var is " + aa); } sart.Format("%s",buf); CString互转char* ///char * TO cstring CString strtest; char * charpoint; charpoint="give string a value"; strtest=charpoint; ///cstring TO char * charpoint=strtest.GetBuffer(strtest.GetLength()); 标准C里没有string,char *==char []==string 可以用CString.Format("%s",char *)这个方法来将char *转成CString。要把CString转成char *，用操作符（LPCSTR）CString就可以了。 CString转换 char[100] char a[100]; CString str("aaaaaa"); strncpy(a,(LPCTSTR)str,sizeof(a)); 27 aprile 1030[Phone Home]编程总结数据结构没想清楚,没有清晰的思路的时候就开始编.导致最后调了好长时间.
中间逻辑思维不严密,很多情况没考虑清楚,最后一点点的加很费事.
变量用过之后得恢复初试值,忘记了,出现了一处错误,查了半天才找到.
慢慢学习吧,努力中ing!(貌似很努力,哈哈) 18 aprile 名人の博客
15 aprile 日子依然......渡口
---------------------------------- 让我与你握别
再轻轻抽出我的手 知道思念从此生根 华年从此停顿 热泪在心中汇成河流 热泪在心中汇成河流 让我与你握别 再轻轻抽出我的手 是那样万般无奈的凝视 渡口旁找不到 一朵相送的花 就把祝福别在襟上吧 而明日明日又隔天涯 ---------------------------------- 01 aprile 情已逝,爱难在......面对着回忆转身的一瞬间
心中竟无一点矫情的悲哀
也无一丝落寞的遗憾
只是静静的告诉自己
一切已经结束了
如此的安静不禁让我有些迷惑
或许以往重要的东西早已变得无所谓了......
这真是造物主的诡计
潜移默化的改变却不让人察觉
当发现时早已面目全非
人非故人,物非常物......
曾经太执著于往事
固执的回味那一点似有似无的温存
失去了自我
也许早该放下了
给自己一个洒脱的理由
我们都该去寻找自己的生活
"去成就自己的人生",你如是说
相交的直线总要各奔东西
交点只有一个
过去了就不能回头
或许相遇便注定了分离
在人生的路上命运没有安排我们一路同行
不知不觉中
情已逝,爱难在
只希望某个雨后的黄昏,我想起的人不是你...... 11 marzo const传奇const传奇
xlander译 --------------------------------------------------------------------------------
简介 当我自己写程序需要用到const的时候，或者是读别人的代码碰到const的时候，我常常会停下来想一会儿。许多程序员从来不用const,理由是即使没用const他们也这么过来了。本文仅对const的用法稍作探讨，希望能够对提高软件的源代码质量有所帮助。 常变量 变量用const修饰，其值不得被改变。任何改变此变量的代码都会产生编译错误。Const加在数据类型前后均可。
例如：
void main(void)
{
const int i = 10; //i,j都用作常变量
int const j = 20;
i = 15; //错误，常变量不能改变
j = 25; //错误，常变量不能改变
}
常指针 Const跟指针一起使用的时候有两种方法。
const可用来限制指针不可变。也就是说指针指向的内存地址不可变，但可以随意改变该地址指向的内存的内容。 int main(void)
{
int i = 10;
int *const j = &i; //常指针, 指向int型变量
(*j)++; //可以改变变量的内容
j++; //错误，不能改变常指针指向的内存地址
}
const也可用来限制指针指向的内存不可变，但指针指向的内存地址可变。 int main(void)
{
int i = 20;
const int *j = &i; //指针,指向int型常量
//也可以写成int const *j = &i;
j++; //指针指向的内存地址可变
(*j)++; //错误,不能改变内存内容
}
看完上面的两个例子，是不是糊涂了？告诉你一个诀窍，在第一个例子中，const用来修饰指针j,j不可变（也就是指向int变量的常指针）；第二个例子中，const用来修饰*j,*j不可变（也就是指向int常量的指针）。
这两种方式可以组合起来使用，使指针和内存内容都不可变。 int main(void)
{
int i = 10;
const int *const j = &i; //指向int常量的常指针
j++; //错误，不能改变指针指向的地址
(*j)++; //错误，不能改变常量的值
}
Const和引用 引用实际上就是变量的别名，这里有几条规则：
声明变量时必须初始化
一经初始化，引用不能在指向其它变量。
任何对引用的改变都将改变原变量。
引用和变量本身指向同一内存地址。
下面的例子演示了以上的规则: void main(void)
{
int i = 10; //i和j是int型变量
int j = 20;
int &r = i; //r 是变量i的引用
int &s; //错误,声明引用时必须初始化
i = 15; //i 和 r 都等于15
i++; //i 和 r都等于16
r = 18; //i 和r 都等于18
printf("Address of i=%u, Address of r=%u",&i,&r); //内存地址相同
r = j; //i 和 r都等于20,但r不是j的引用
r++; //i 和 r 都等于21, j 仍等于20
}
用const修饰引用,使应用不可修改，但这并不耽误引用反映任何对变量的修改。Const加在数据类型前后均可。 例如：
void main(void)
{
int i = 10;
int j = 100;
const int &r = i;
int const &s = j;
r = 20; //错，不能改变内容
s = 50; //错，不能改变内容
i = 15; // i和r 都等于15
j = 25; // j和s 都等于25
}
Const和成员函数 声明成员函数时，末尾加const修饰，表示在成员函数内不得改变该对象的任何数据。这种模式常被用来表示对象数据只读的访问模式。例如：
class MyClass
{
char *str ="Hello, World";
MyClass()
{
//void constructor
}
~MyClass() {
//destructor
}
char ValueAt(int pos) const //const method is an accessor method {
if(pos >= 12)
return 0;
*str = 'M'; //错误，不得修改该对象
return str[pos]; //return the value at position pos
}
}
Const和重载 重载函数的时候也可以使用const,考虑下面的代码：
class MyClass
{
char *str ="Hello, World";
MyClass()
{
//void constructor
}
~MyClass() {
//destructor
}
char ValueAt(int pos) const //const method is an accessor method {
if(pos >= 12)
return 0;
return str[pos]; //return the value at position pos
}
char& ValueAt(int pos) //通过返回引用设置内存内容 {
if(pos >= 12)
return NULL;
return str[pos];
}
}
在上面的例子中，ValueAt是被重载的。Const实际上是函数参数的一部分，在第一个成员函数中它限制这个函数不能改变对象的数据，而第二个则没有。这个例子只是用来说明const可以用来重载函数，没有什么实用意义。 实际上我们需要一个新版本的GetValue。如果GetValue被用在operator=的右边，它就会充当一个变量；如果GetValue被用作一元操作符，那么返回的引用可以被修改。这种用法常用来重载操作符。String类的operator[]是个很好的例子。（这一段译得很烂，原文如下：In reality due to the beauty of references just the second definition of GetValue is actually required. If the GetValue method is used on the the right side of an = operator then it will act as an accessor, while if it is used as an l-value (left hand side value) then the returned reference will be modified and the method will be used as setter. This is frequently done when overloading operators. The [] operator in String classes is a good example.） class MyClass {
char *str ="Hello, World";
MyClass()
{
//void constructor
}
~MyClass() {
//destructor
}
char& operator[](int pos) //通过返回引用可用来更改内存内容 {
if(pos >= 12)
return NULL;
return str[pos];
}
}
void main(void) {
MyClass m;
char ch = m[0]; //ch 等于 'H'
m[0] = 'M'; //m的成员str变成：Mello, World
}
Const的担心 C/C++中，数据传递给函数的方式默认的是值传递，也就是说当参数传递给函数时会产生一个该参数的拷贝，这样该函数内任何对该参数的改变都不会扩展到此函数以外。每次调用该函数都会产生一个拷贝，效率不高，尤其是函数调用的次数很高的时候。
例如：
class MyClass {
public:
int x;
char ValueAt(int pos) const //const method is an accessor method
{
if(pos >= 12)
return 0;
return str[pos]; //return the value at position pos
}
MyClass()
{
//void constructor
}
~MyClass()
{
//destructor
}
MyFunc(int y) //值传递
{
y = 20;
x = y; //x 和 y 都等于 20.
}
}
void main(void) {
MyClass m;
int z = 10;
m.MyFunc(z);
printf("z=%d, MyClass.x=%d",z,m.x); //z 不变, x 等于20.
}
通过上面的例子可以看出，z没有发生变化，因为MyFunc()操作的是z的拷贝。为了提高效率，我们可以在传递参数的时候，不采用值传递的方式，而采用引用传递。这样传递给函数的是该参数的引用，而不再是该参数的拷贝。然而问题是如果在函数内部改变了参数，这种改变会扩展到函数的外部，有可能会导致错误。在参数前加const修饰保证该参数在函数内部不会被改变。 class MyClass
{
public:
int x;
MyClass()
{
//void constructor
}
~MyClass()
{
//destructor
}
int MyFunc(const int& y) //引用传递, 没有任何拷贝
{
y =20; //错误，不能修改常变量
x = y
}
}
void main(void) {
MyClass m;
int z = 10;
m.MyFunc(z);
printf("z=%d, MyClass.x=%d",z,m.x); //z不变, x等于10.
}
如此，const通过这种简单安全机制使你写不出那种说不定是什么时候就会掉过头来咬你一口的代码。你应该尽可能的使用const引用，通过声明你的函数参数为常变量（任何可能的地方）或者定义那种const method，你就可以非常有效确立这样一种概念：本成员函数不会改变任何函数参数，或者不会改变任何该对象的数据。别的程序员在使用你提供的成员函数的时候，不会担心他们的数据被改得一塌糊涂。 右左法则----复杂指针解析右左法则----复杂指针解析
C标准的声明规则，是用来解决如何创建声明的，而右左法则是用来解决如何辩识一个声明的，两者可以说是相反的。右左法则的英文原文是这样说的： The right-left rule: Start reading the declaration from the innermost parentheses, go right, and then go left. When you encounter parentheses, the direction should be reversed. Once everything in the parentheses has been parsed, jump out of it. Continue till the whole declaration has been parsed.
这段英文的翻译如下： 右左法则：首先从最里面的圆括号看起，然后往右看，再往左看。每当遇到圆括号时，就应该掉转阅读方向。一旦解析完圆括号里面所有的东西，就跳出圆括号。重复这个过程直到整个声明解析完毕。
笔者要对这个法则进行一个小小的修正，应该是从未定义的标识符开始阅读，而不是从括号读起，之所以是未定义的标识符，是因为一个声明里面可能有多个标识符，但未定义的标识符只会有一个。
现在通过一些例子来讨论右左法则的应用，先从最简单的开始，逐步加深：
int (*func)(int *p);
首先找到那个未定义的标识符，就是func，它的外面有一对圆括号，而且左边是一个*号，这说明func是一个指针，然后跳出这个圆括号，先看右边，也是一个圆括号，这说明(*func)是一个函数，而func是一个指向这类函数的指针，就是一个函数指针，这类函数具有int*类型的形参，返回值类型是int。
int (*func)(int *p, int (*f)(int*));
func被一对括号包含，且左边有一个*号，说明func是一个指针，跳出括号，右边也有个括号，那么func是一个指向函数的指针，这类函数具有int *和int (*)(int*)这样的形参，返回值为int类型。再来看一看func的形参int (*f)(int*)，类似前面的解释，f也是一个函数指针，指向的函数具有int*类型的形参，返回值为int。
int (*func[5])(int *p);
func右边是一个[]运算符，说明func是一个具有5个元素的数组，func的左边有一个*，说明func的元素是指针，要注意这里的*不是修饰func的，而是修饰func[5]的，原因是[]运算符优先级比*高，func先跟[]结合，因此*修饰的是func[5]。跳出这个括号，看右边，也是一对圆括号，说明func数组的元素是函数类型的指针，它所指向的函数具有int*类型的形参，返回值类型为int。
int (*(*func)[5])(int *p); func被一个圆括号包含，左边又有一个*，那么func是一个指针，跳出括号，右边是一个[]运算符号，说明func是一个指向数组的指针，现在往左看，左边有一个*号，说明这个数组的元素是指针，再跳出括号，右边又有一个括号，说明这个数组的元素是指向函数的指针。总结一下，就是：func是一个指向数组的指针，这个数组的元素是函数指针，这些指针指向具有int*形参，返回值为int类型的函数。
int (*(*func)(int *p))[5];
func是一个函数指针，这类函数具有int*类型的形参，返回值是指向数组的指针，所指向的数组的元素是具有5个int元素的数组。
要注意有些复杂指针声明是非法的，例如：
int func(void) [5];
func是一个返回值为具有5个int元素的数组的函数。但C语言的函数返回值不能为数组，这是因为如果允许函数返回值为数组，那么接收这个数组的内容的东西，也必须是一个数组，但C语言的数组名是一个右值，它不能作为左值来接收另一个数组，因此函数返回值不能为数组。
int func[5](void);
func是一个具有5个元素的数组，这个数组的元素都是函数。这也是非法的，因为数组的元素除了类型必须一样外，每个元素所占用的内存空间也必须相同，显然函数是无法达到这个要求的，即使函数的类型一样，但函数所占用的空间通常是不相同的。
实际当中，需要声明一个复杂指针时，如果把整个声明写成上面所示的形式，对程序可读性是一大损害。应该用typedef来对声明逐层分解，增强可读性，例如对于声明：
int (*(*func)(int *p))[5];
可以这样分解：
typedef int (*PARA)[5];
typedef PARA (*func)(int *); 这样就容易看得多了。 c++清屏命令#include <process.h>
system("cls") 一段有意思的代码#include <iostream.h>
int *p = NULL;
int *fFun(void)
{ int i = 0; return &i; } void subFun(void)
{ (*p)--; } void gFun(void)
{ int j; for(j = 0;j<10;j++)
{ subFun(); cout<<j; } } int main(void)
{ p = fFun(); gFun(); return 0; } 上网看见了有一个有意思的代码.据说是一个公司的面试题目,很有意思
程序运行结果是死循环输出-1
分析一下这个程序
fFun()返回一个指针给P,P指向原来i的地址,i在函数调用的时候压栈,调用完了i出栈
但是这个地址被给了P,然后调用gFun,在gFun里j压栈,占了原来i的内存地址
这是P就指向了j,然后 (*p)--,j++,程序进入死循环.... 09 marzo 不为伤心,只因无奈心情不好，却不知道从何说起
不为伤心只因无奈 被曾经心爱的女人冠以“不配” 我无言 无语 以至于...... 无奈 庄子⊙秋水中，庄子有言:
“计人之所知，不若其所不知； 其生之时，不若未生之时。” 是啊，对于一个人
已知和未知比起来如沧海一粟 人生在世如白驹过隙，忽然而已 但人却总是在懵懂而短暂的生命里 沉沦于烦恼之中不能自拔 得而不喜，失而不忧
生而不悦，死而不祸 庄子的超然境界真的存在吗？
或者只是空想出来让人向往的...... 从高中开始就一个人在外地上学
曾经快乐的游戏人间 也曾为理想努力拼搏 曾经相信灵魂的纯净
也曾目睹人性的丑恶 曾经单纯的喜欢一个人
也曾对爱无所谓 生活中遭遇了种种人
经历了种种事 学会了许多，改变了许多...... 在这种种改变当中
最大的改变就是变"懒"了 懒得去回忆，因为回忆太沉重了 懒得去伤心，因为伤心太无聊了 懒得去生气，因为生气太无用了 懒得只能一笑而过
道一句无奈 而唯一没有改变的是---我依然很骄傲
哼唱着范玮琪一首《最初的梦想》 我知道我会昂起头骄傲的走下去...... 02 marzo 开学了................开学快两个星期了,总想写点什么,可是总是觉得没什么好写的!
生活很宁静,心情很平淡
没有什么太高兴的事,也没有什么伤心的事!
期末考试成绩还不错,有了一点好好学习的冲动.
六级也过了,虽然分不高
但是算是过了,不用太着急了,可以准备考研了
这样的生活也写不出什么了
以前总喜欢写点伤心事
把自己那丁点不开心事说得像大地震似的
现在想想觉得实在没什么必要,而且很可笑
象是在无病呻吟以博取别人的同情
孰不知只能让别人嗤之以鼻,谓之"无聊"
因为这实在是很小家子气
让人觉得你很软弱,你很幼稚
真正的强者是不会轻易认输的
SO 我要做一个强者25 febbraio I/O流控制符1)浮点显示控制
a)setprecision(n) ：控制输出显示浮点数的数字个数（默认6） b)setprecision(n)+setiosflags(ios::fixed)：控制定点输出表示小数位数 c)setprecision(n)+setionsflags(ios::scientific)：控制指数形式输出时小数位数 2)设置输出宽度setw(n) 3)设置输出形式八进制和十六进制 dec(十) 、oct（八）、hex（十六） 4)设置填充字符 setfill(‘')+setw(n) 5)设置对齐方式 setiosflags(ios::left) (默认) setiosflags(ios::right) 6)设置强制显示小数和符号 setiosflags(ios::showpoint) setiosflags(ios::showpos) 17 gennaio 恋爱像赌博2006年1月17日。。。。
大学二年级，第二次过年回家没座。。。。
阼夜无眠，突然冒出个想法---恋爱像赌博
筹码便是感情
想想觉得真的是太经典了
痴情者谓之大气
出手阔绰，每次都是全部家当押上
而且押的都是1赔16的
回报很大，当然风险也是一样的
也许几次就可以赢很多
但是他输不起
一旦输掉了，他便一无所有
薄情者谓之小气
出手小气，每次最多只押8分家当
剩2分，输了还可以翻本
而且押的是1赔1的
赢面大，风险不大
但是用8分的家当做赌注
赢来的最多也就是8分
8分的爱情，你喜欢吗？
喜欢的人谓之 “有理性”
但是理性也不是总有的
赢得多了，难免从有理性变成感性
上了层次，从小气变成大气
一注押光所有的家当
不喜欢的人谓之 “不投入”
当然感性也能变理性
每次都输的精光
再傻的人也变的精明了吧
每次押得越来越少
下了层次，从大气变小气
谨小慎微起来
你想怎么赌那? 16 gennaio 亲爱的，你还欠我幸福...... [转载于NKBBS.ORG] 听到王菲浅吟低唱着这个句子的时候，阿朱如花的笑靥正在青石桥旁小镜湖边渐渐 凋零，乔峰在滂沱的夜雨中泪雨也滂沱。你给我保护，我还你祝福，你英雄好汉需要抱 负，可你欠我幸福，拿什么来弥补？ 终是塞上牛羊空许约。 空许约，空许约，幸福永远未完成…… 我多么想和你有一个深深的拥抱之后，转身离去。情深未变却寒盟。终究差了那么 一点点，幸福转眼消逝。从此一个人，日日自己关门，一个人熄灯。其实也没什么不 好，只不过寒冷的夜里少了一个人的温暖，只不过幸福不再完整…… 陈家洛不愿负天下人，便负红颜。一个为他香消玉殒，一个因他寂寞余生。也许他 的命运早早已是注定，在那条命定的路上，没有预设爱情，以及幸福…… 张无忌放弃了江湖与江山，他把幸福给了赵敏，却把牵挂给了小昭，把漂泊给了蛛 儿，把憾恨给了芷若…… 杨过和小龙女最终做了神仙眷侣。也许他知道，也许他不知道，也许他装作不知 道，程英和陆无双为他负尽青春抛尽韶华，郭襄为他天涯思君念念不忘；也许他记得， 也许他不记得，曾经有一个叫公孙绿萼的姑娘把一生停驻在他一刹那的目光里。而他所 能给的，也只能是一曲清箫、三枚金针或者某一刻的眷顾而已。 这世间，太少的相濡以沫，太多的相忘江湖…… 我们曾经深深地爱过一些人。爱的时候，把朝朝暮暮当作天长地久，把缱绻一时当 作被爱了一世，于是承诺，于是奢望执子之手，幸福终老。然后一切消失了，然后我们 终于明白，天长地久是一件多么可遇不可求的事情，幸福是一种多么玄妙多么脆弱的东 西。也许爱情与幸福无关，也许这一生最终的幸福与心底最深处的那个人无关，也许将 来的某一天，我们会牵住谁的手，一生细水长流地把风景看透。 其实承诺并没有什么，不见了也不算什么，所有的一切自有它的归宿。我们学着看 淡，学着不强求，学着深藏，把你深深埋藏，藏到岁月的烟尘企及不到的地方…… 只是，只是为什么在某个落雨的黄昏，在某个寂寂的夜里，你还是隐隐地在我心里 淡入、淡出；淡出、淡入，拿不走，抹不掉。 亲爱的，我，曾经，这样爱你；我，曾经以为，你是幸福的原因…… 10 gennaio 大学随想终于要回家拉！还有一科就考拉！ 这一转眼就一年半过去了，大学一半都没了．．．． 时间过的还真快 想想到底学到了什么．．．． 有点茫然，似乎学了很多东西，又似乎什么也不会 大学最后到底留给我们什么那 曾经听过这么一个说法
大学毕业之后，还记得的东西就是大学留给你的东西， 然后带着自己建立的朋友圈和拖欠的帐单进入社会．．．．．
想想也有些道理，出外靠朋友嘛 ．．．．．．．．．．．．．． 不过咱不是得追求点高尚的嘛
泉涸，鱼相与处于陆，相呴以湿，相濡以沫，不如相忘于江湖。 与其誉尧而非桀也，不如两忘而化其道－－－《庄子·大宗师》
相濡以沫这个词大家都听过，不过接下来谁知道那 呵呵，就是那句＂不若相忘与江湖＂ 这段话的意思就是： 两条鱼被困在车辙里面，为了生存,两条小鱼彼此用嘴里的湿气来喂对方。 这样的情景也许令人感动，但是，这样的生存环境并不是正常的，甚至是无奈的。 对于鱼儿而言,最理想的情况是，海水终于漫上来， 两条鱼也终于要回到属于它们自己的天地， 最后，他们，相忘于江湖。在自己最适宜的地方，快乐的生活， 忘记对方，也忘记那段相濡以沫的生活。
当然，我们是达不到庄子的境界的 皆不能忘，朋友如是，恋人如是 去哪都想着靠朋友， 到最后脑子里装满回忆，沉甸甸的 有点压的人透不过气 与其如此，不如洒脱一些 ＂相忘于江湖＂做不到就＂相望于江湖＂吧 各自去寻找属于自己的一片海， 在人生舞台上演绎自己的人生
有句话如是说 ＂心有多大，舞台就有多大＂
我的心比海大 30 dicembre 我的爱情没有围巾长[转载于NKBBS.ORG]
28 dicembre 韩语发音规则１．浊音化 当ㄱ ㄷ ㅈ ㅂ 在第一个音时，发［Ｋ］［Ｔ］［Ｃ］［Ｐ］，而当在后面时，就发 ［Ｇ］［Ｄ］［Ｚ］［Ｂ］，这就是浊音化。其实这个规律在以前说过，所以比较好理解 ２．连音化 当韵尾与元音相连时，韵尾要做此元音的头音。例：한 국 어 韩国语－［한 구 거 ］ 注意：이 것 은 这个 －－［이 거 슨 ] "ㅅ"做韵尾时读作［ㄷ］，但当连音后就不能读[ㄷ]了，要读它的本音。 ［ㅎ］与后面的元音相连，要脱落。例：좋 아 요 好－－[조 아 요 ] ３．腭化 韵尾ㄷ , ㅌ ［ㄷ + 이 ］－－［ 지 ］ ［ㅌ + 이］－－［ 치 ］ 例：맏 이 老大 －－ ［마 지 ］ 같 이 一起 －－［가 치 ］ 4．送气音化 当ㅂ ㅈ ㄷ ㄱ与其前后的［ㅎ］相连时，就要变成ㅍ ㅊ ㅌ ㅋ 例：앉 히 다 使就坐－－［안 치 다 ] 못 하 다 不能做－［모 타 다 ］ 与连音化不同，送气音化与后面ㅎ相连，要发其韵尾音，而不是本音． ５．紧音化 当韵尾ㅂ ㄷ ㄱ 与ㅂ ㅈ ㄷ ㄱ ㅅ 相连时，变为ㅃ ㅉ ㄸ ㄲ ㅆ 例：듣 다 听－－듣 따 8086/8088 BIOS 中断
26 dicembre 剖析浮点数的存储形式众所周知，浮点数（float）在计算机中占4个byte即32bit，这32bit是如何表示一个浮点数的那？经过查资料，我们得知，浮点数是按照如下格式进行存储的： 例如：0.5的二进制形式是0.1 它用浮点数的形式写出来是如下格式 0 01111110 00000000000000000000000 符号位 阶码 小数位 正数符号位为0，负数符号位为1 阶码是以2为底的指数 小数位表示小数点后面的数字
下面我们来分析一下0.5是如何写成0 01111110 00000000000000000000000
首先0.5是正数所以符号位为0 再来看阶码部分,0.5的二进制数是0.1,而0.1是1.0*2^(-1),所以我们总结出来: 要把二进制数变成(1.f)*2^(exponent)的形式,其中exponent是指数 而由于阶码有正负之分所以阶码=127+exponent; 即阶码=127+(-1)=126 即 01111110 余下的小数位为二进制小数点后面的数字,即00000000000000000000000
由以上分析得0.5的浮点数存储形式为0 01111110 00000000000000000000000
现在我们明白了一个数是如何表示成浮点数形式,下面我们来编一个c++程序来验证它. C++代码如下:
#include <iostream.h> void main() { float f; int a[4][8];
cin>>f; unsigned char b[4]; for(int i=0;i<4;i++) { b[i]=*((char *)&f+i); } for(i=0;i<4;i++) { int temp=b[i]; for(int j=0;j<8;j++) { a[i][j]=temp%2; temp/=2; } } cout<<a[3][7]<<" "; for(i=6;i>=0;i--) { cout<<a[3][i]; } cout<<a[2][7]<<" "; for(i=6;i>=0;i--) { cout<<a[2][i]; } for(i=1;i>=0;i--) { for(int j=7;j>=0;j--) { cout<<a[i][j]; } } cout<<endl; }
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
