荔园在线

荔园之美,在春之萌芽,在夏之绽放,在秋之收获,在冬之沉淀

[回到开始] [上一篇][下一篇]


发信人: Version (西风。。), 信区: Program
标  题: 妖藏巨细(上)[zz]
发信站: 荔园晨风BBS站 (Fri Jun 20 09:51:39 2003), 站内信件

标题     妖藏巨细(上)    wtong(原作)

关键字     ANSI C++



妖藏巨细(上)
前言:我是一个马上就要离开学校的学生,这是我一两个月前写的第一篇文章,文章中的
hustli是我的一位师弟,现在是南京大学小百合CPlusPlus版的版主,为人热情诚恳,mud
是小百合的一位网友,感谢他们让我知道不仅是阅读,其实写作也是很快乐的。这篇文章
,主要是为回答hustli提出的前三个问题和最后一个问题以及mud提出的第四个问题。我会
陆续将近两个月的文
章全发到CSDN,很想申请一个专栏,不知能否如愿。其中的文章我会在原来的基础上改正
一些技术细节、用词不当等小错误,希望大家指正。不知道为什么,可能是文章太长,只
能分两部分发表。

有句话叫妖藏巨细,用英语说是“The devil is in the
detail.”(魔鬼躲藏在细节之中。)在我所了解的几种语言中,C++正好就是魔鬼频繁出
没的森林。如果你是一个刚学魔法没有几天的新手,不幸过早的遇上魔鬼,而身边又没有
一个道行高深的魔法师,那真是糟糕之极,一个小小的魔鬼就可能击碎你刚刚建立的一点
自信心。当然,每个硬币也都有它的另外一面,对一个有了一定级别的魔法师,与魔鬼斗争
可能正是他的乐趣所
在。

hustli似乎正是这样一个人。下面我尝试来做一次钟馗,试着解决hustli和mud抛出的几
个小魔鬼。【注1】

注1:本人不喜欢魔鬼,这次只是为了纯粹的乐趣,因为对我,经常是道高一尺,魔高一
丈,功力太浅,怕贻笑大方。

1.逗号(,)和加号(+)都是运算符,为什么逗号,不可以编译期间确定?加号+却可以
?int a[2,3];错误!  int a[2+3];正确!

Answer:加号"+"是一个运算符(operator),但是逗号","却有两种用法。第一种用法
是作为分隔符(separator),比如我们最常见到的int i ,j ,k;但是还有一种用法,比
较不常见,作为逗号运算符(comma operator)使用,也叫顺序运算符(sequence
operator),最常见的使用是在for语句中,例如

for( int i = 0, j = i; i < max; ++i )…;

其实顾名思义,既然叫顺序运算符,那就是从左往右一个一个的求值,最后整个表达式的
结果是最后一个求值的结果。例如:

int i,j,k;

i = 2, j = i+2, k = 3*j, i + j + k;

第二个语句从左往右一个一个的求值,i=2, j=i+2=4, k=3*j=12, i+j+k=18, 整个表达式
结果是18,类型是i+j+k的类型int。

但是在所有的运算符优先级中,逗号运算符的优先级是最低的,而且标准也规定在逗号运
算符中的表达式求值是动态确定的,既然是动态确定,那当然是不可以编译期间确定。因
此,int
a[2,3];中的逗号运算符表达式需要在运行时确定是3,但是数组的个数必须在编译期间确
定,矛盾,编译不可能通过。标准中有规定,[const_expression],数组个数应该是一个
const_expression,但是在这个const_expression中,comma operator是不可以使用的。
【注2】

注2:请参考ANSI C++标准5.19

现在我们来做一个假设,如果逗号运算符表达式可以在编译时确定,也就是说int
a[2,3];即为int a[3];那么一个有fortran背景的程序员第一次看到这个表达式,他肯定
会认为是int
a[2][3];以后的麻烦肯定就是如影随形。因此,标准禁止这种用法是非常明智的。不过,
有一些编译器对C语言做了一些扩展,比如著名的GNU家族的gcc编译器,因此这个语句在
gcc下是可以通过的,但是请记住,gcc是C语言编译器,g++才是C++语言编译器。下面的
例子:

int a[2,3,4];

VC7.1不能通过;DEVC++4.9.7可以通过,表示int a[4];

2.如下的数组初始化,不能用static修饰数组,怎么改?

       class A

       {

        public:

            A():a({1,2}) {}   //这样不行!

        private:

            const int a[2];

        };

Answer: 一个在类中,使用const修饰的,非静态数组不能被显示初始化。但是在这个问
题中,数组a是个常量数组,因此它又不可能在构造函数体内被初始化。数组a不能被初始
化的本质原因在于a是一系列连续对象的集合,它不能代表一个对象。例如:

int a[2],b[2]={1,2};

a=b;//不合法,a不能被赋值!

A只是一个数组名,它有两个意义,1.sizeof(a)中,a表示整个数组,sizeof(a)结果是整
个数组所占内存的字节数;2.int j = a[1]中,a[1]是*(a+1)的另一种写法,a的值就是
数组首元素的地址。上面的例子有两种解决办法。

(1).将a[2]转移到类层次中,即将const int a[2]改为static const int a[2],你可以认
真的想一想,既然a[2]是const,那么每一个对象真的需要单独的一份a[2]吗?大部分时
候答案应该是no。现在类定义如下:

       class A

       {

        public:

            A(){}

        private:

            static const int a[2];

        };

const int A::a[2] = {1,2};//在实现文件中。

(2)将数组改为指针,即const int a[2]改为const int* const a; 现在类定义如下:

                const int ca[2] = {1,2};//注意

       class A

       {

        public:

            A():a(ca){}

        private:

            const int* const a;

        };

本人更喜欢第一种方案!

(to be continued!)

吴桐写于2003.4.26

最近修改2003.6.15



作者相关文章:
auto_ptr_ref的奇妙(下)(原作)
auto_ptr_ref的奇妙(上)(原作)
行百里半九十(原作)





对该文的评论 人气:1680
      wingfiring(2003-6-19 18:43:37)

1.数组传递可以采用包裹的办法,简单的说就是用struct包裹起来,struct时可以值传递
的:
struct ArrData
{
        int data[2];
};
不必为ArrData写构造函数,就象数组一样的使用:
const ArrData cdata = {1,2};
class A
{
public:
  A():a(cdata){}
private:
  const ArrData a;
};
这个方法也可以用在以数组作为函数参数的地方。

2.step_by_step 的意思是说gcc不但可以编译C/C++,还可以编译FORTRAN,ada...我有没
有说错?

      leeseon(2003-6-19 18:35:49)

twong的第二种方案没有问题,因为只是对全局数组的引用,根本不需要值拷贝,因为不
需要你自己来释放全局数组的内存。

所以反而plainsong的方案是不太好的,因为就算你要为每一个对象都保存一个初状态,
如你的方案所示,只有析构函数还是不够的,因为你需要提供进行“值拷贝”的拷贝构造
函数与重载=运算符。

其实还有一个方案能解决,那就是不用数组,而是使用vector,这个方案是很多C观点太
强的人不愿用的,但是我觉得如果不是强烈要求效率,你没有理由非要用数组而不用
vector。

      wtong(2003-6-19 17:41:31)

感谢大家的各种意见,不论是肯定还是批评,都非常愿意看见:)
plainsong :谢谢你的批评。
tlovexyj :谢谢你的肯定。

step_by_step :你说的很对,可能我说的不够清楚,gcc是编译C语言程序的命令和程序



      step_by_step(2003-6-19 16:18:14)

gcc is not only gnu c compiler.
gcc = gnu compiler collection.


      tlovexyj(2003-6-19 14:59:44)

楼下的兄弟是从OO的角度来看,说得很对。
但是解法却给效率上带来开销。

窃以为,wtong的第一种解法,在大多数情况,不失为一个好解。
PS,俺就是用的第一种-.-b

      plainsong(2003-6-18 18:30:46)

关于“数组成员初始化”的问题,作者提出的两种解决方法都是错误的。虽然可以通过编
译,但都和原意不符。
1:把对象级成员改为类级成员当然是不正确的,本来类A的两个对象都可以有自己的状态
(假设类A再没有其它成员,状态完全由成员a确定),但修改后类A的两个对象就不再有自
己的状态了,因为这时成员a是类A所有对象共用的。
2:用指针代替数组本来是可行的,虽然结果并不完全一样,但可以看作是实现的变化,
其含义没有发生变化;问题出在作者在对指针被始化时使用了“指针赋值”而不是“值拷
贝”,这样就导致类A的不同对象的成员a仍然指向同一个数组,结果仍然没有自己的状态

正确解决方法:
1:使用constructor。数组也有constructor吗?没有,但我们可以用一个结构把它封装
起来:
class A
{
public:
  A():a(1,2){}  private:
  struct AryData
{
  int Data[2];
  AryData(int V1, int V2){Data[0] = V1;Data[1] = V2;}
};
const AryData a;
};

这种方法最符合原意。

2:使用指针,但要复制初始值。

const int ca[2] = {1,2};
class A
{
  int * AryDup(const int * Data){int * Result; Result = new int[2];
std::memmove(Result, Data, sizeof(int) * 2);return Result;}
public:
A():a(AryDup(ca)){}
~A(){delete []a;};//注意一定要有析构函数,用来释放指针。
private:
const int* const a;
};


--
                      *
          *                                  *
                          *             *
                      no more to say
                  ★     just wish you   ★
                            good luck

※ 来源:·荔园晨风BBS站 bbs.szu.edu.cn·[FROM: 192.168.1.50]


[回到开始] [上一篇][下一篇]

荔园在线首页 友情链接:深圳大学 深大招生 荔园晨风BBS S-Term软件 网络书店