现在的位置: 首页 > 自动控制 > 工业·编程 > 正文

C/C++ 一些细节问题

2012-11-24 21:06 工业·编程 ⁄ 共 3010字 ⁄ 字号 暂无评论

一、无符号,有符号数的比较问题

    C/C++中规定,两种类型比较,如果两种类型的内存占用一致的话。则默认转型至无符号数,如果两种类型内存占用不移植,则默认转型至内存占用更大的类型。

例如:

#include <stdio.h>  
 
int main(int argc, char **argv)  
{  
    int  i=-1;  
    unsigned int j = 2;  
    if(i<= j)printf("Hello");  
    else printf("world");  
    return 0;  

这样子的话,理论上会输出world。因为unsigned int 和int 的内存占用一致(都是4B),所以会转型至unsigned,-1的二进制表示为0xFFFFFFFF,所以如果无符号的话是一个非常非常大正数,自然会输出world

然而下面一个例子,不一样了

Code:
#include <stdio.h>  
 
int main(int argc, char **argv)  
{  
    long long i=-1;  
    unsigned int j = 2;  
    if(i<= j)printf("Hello");  
    else printf("world");  
    return 0;  

这样就会输出Hello,因为会转型到long long。

当然,这只是C/C++的标准,至于遵守不遵守标准,那是编译器的问题。以上代码用GCC和VC都编译过,和标准符合。

这么繁杂的问题,如何解决呢?

我个人的想法是,可以由两种解决办法:

1、尽量少的使用无符号数。或者不要因为没有负数就是用无符号数。有的时候,潜在的风险未必值得你这么做。尤其当代码量超多的时候。

2、比较时尽量类型转换。。我是个懒人,这种做法。。。。实在是不现实。。每次都要多打多少字啊。呵呵

二、union的扯淡用法

如何将一个int的中间16位的末8位左移三位,其他的位不变呢?其实这个问题什么算法也不需要,只需要使用union这个类型;

#include <iostream>  
using namespace std;  
union int_  
{  
    unsigned int whole;  
    struct {  
        unsigned char a;  
        unsigned char b;//这里的abcd顺序也许和计算机的地址排列有关系,大端派,小端派。呵呵。不过X86下这样没错
        unsigned char c;  
        unsigned char d;  
    } bytes;  
};  
int main()  
{  
    int_ t;  
    t.whole = 257;  
    t.bytes.b<<=3;  
    cout<<t.whole<<endl;  
    return 0;  

就是像这里的代码一样。union的实际作用,是将其中声明的变量的地址,对齐到同一地点,这样正常情况下,就达到了同一时刻只有一种变量的效果。不过,如果只是地址一致的话,两种变量实际上同时都存在,所以对一个union中的变量进行操作就会影响到另一个变量的值,于是就有了这种效果。

值得注意的是:

1、这样做,必须小心字符填充(字对齐?我对专业名词一向记不住)。不一定你声明是什么,内存占用就是多大。

2、有些编译器为了避免误操作,将每次取另一种union的类型是,都会将内存置零。

这样做,可能应用作用并不大,不过至少理解了union的实际意义,至于嵌入式方面也许确实有一些应用,毕竟对位的精确操作是嵌入式的需求。而这种方法,实际运行上并没有消耗,也符合嵌入式对性能的要求。

另:还有一种方法实现这个效果,那就是用 引用 。具体方法,我就不多写了,引用的类型强制转换。

三、构造函数时值的初始化

前几天,有个同学刚学C++,我一看就帮他写了个作业(...主要是他们学过C,老师留的是预习作业,而他写的代码基本没问题,但是就是没有C++的感觉)。其中有一点写下来:

首先,什么是构造函数时成员变量的初始化:

有的人说,在构造函数体里写,什么this->math= XXX;啊,是初始化。我想,这是完全错误的。初始化的写法应该是在构造函数实现时,后面跟着:,然后再在后面依次写  变量名(初始化值)。如果没有指定初始化的值,则编译器为其初始化一个值(这个是个悲剧,因为有时候成员变量忘了初始化,使用时就会出现垃圾)。而在函数体内的“初始化”,实际上是对变量的第二次赋值(第一次是初始化的时候)。所以速度上会慢下来。

其次,初始化顺序。

其实,我想说的是,永远不要顺序相关的初始化。例如

Code:
SomeClass:SomeClass(int r,int v):m_r(r),m_v(v),m_total(m_r+m_v)  
{  
}  
这样的初始化,m_total的值依赖于m_r和m_v的值。有的人说了,我明明在之前已经初始化m_r和m_v了啊?其实不然。实际初始化的顺序,和这里的顺序,一点关系也没有。真的。真正有关系的,是变量在类里声明的顺序。

Code:
SomeClass  
{  
int m_r;   //这是第一个被初始化的变量
int m_v;   //这是第二个
int m_total;   //这是第三个
}; 
如果这样的代码,确实没有问题,但是如果把m_total向上提一个位置,那这个初始化就是没有意义的了。。(也许你会奋斗一晚上,然后说,我编译器有问题。。恩。呵呵)

解决的办法,尽量不要做循序相关的初始化。即使你知道这个原理,也说不定哪天心血来潮修改下.h文件(更多的情况是更新了UML文件,然后输出变量的顺序变了。。。)。那这就绝对的悲剧了。

再次,是我一个困惑的问题。

首先我们知道,初始化比在函数体内部赋值速度快,但是,愿望是美好的,现实是残酷的,有的时候,初始化那仅有一句的statement不足以解决问题。。这可咋整。

有一个折中的方法:

Code:
struct Student {  
    long long studentNumber;  
    string name;  
    float math;  
    float english;  
    float score;  
    Student(long long sn,string n,float m,float e)  
    :studentNumber(sn),name(n),math(m),english(e),score(getScore(m,e))  
    {  
    }    
private:  
    static float getScore(float m,float e)  
    {  
        if(m<50)m=50;  
        if(e<50)e=50;  
        return (6*(m-50)/10+4*(e-50)/10)/10;  
    }  
}; 
这里声明一个private static函数,来计算绩点,返回值来进行初始化。这样既是在初始化内部完成的,又可以无限制代码的长度。

问题也来了。这样的值传递,应该也是消耗的,究竟是这么初始化消耗的多,还是在函数体内的消耗多呢?不过至少一点,这种在返回指针的情况下;肯定是比在函数体内“初始化”快,而且,这样写出的代码更有条理。

差不多就写到这了,最后一个问题真心求解.

给我留言

留言无头像?