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函数，来计算绩点，返回值来进行初始化。这样既是在初始化内部完成的，又可以无限制代码的长度。