cjj123.htm

c++的一些程序

                              <P>double a[100], sum1, sum2, sum3, sum4, 
                              sum；<BR>int i；<BR>sum1 = sum2 = sum3 = sum4 = 
                              0.0；<BR>for (i = 0； i &lt;； 100； i += 
                              4)<BR>{<BR>　　sum1 += a[i]；<BR>　　sum2 += 
                              a[i+1]；<BR>　　sum3 += a[i+2]；<BR>　　sum4 += 
                              a[i+3]；<BR>}<BR>sum = (sum4+sum3)+(sum1+sum2)； 
                              <P>　　要注意的是：使用4 
                              路分解是因为这样使用了4阶段流水线浮点加法，浮点加法的每一个阶段占用一个时钟周期，保证了最大的资源利用率。 

                              <P>提出公共子表达式 
                              <P>　　在某些情况下，C++编译器不能从浮点表达式中提出公共的子表达式，因为这意味着相当于对表达式重新排序。需要特别指出的是，编译器在提取公共子表达式前不能按照代数的等价关系重新安排表达式。这时，程序员要手动地提出公共的子表达式（在VC.net里有一项“全局优化”选项可以完成此工作，但效果就不得而知了）。 

                              <P>推荐的代码 
                              <P>float a, b, c, d, e, f；<BR>...<BR>e = b * c / 
                              d；<BR>f = b / d * a；<BR>float a, b, c, d, e, 
                              f；<BR>...<BR>const float t(b / d)；<BR>e = c * 
                              t；<BR>f = a * t； 
                              <P>推荐的代码 
                              <P>float a, b, c, e, f；<BR>...<BR>e = a / c；<BR>f 
                              = b / c；<BR>float a, b, c, e, f；<BR>...<BR>const 
                              float t(1.0f / c)；<BR>e = a * t；<BR>f = b * t； 
                              <P>　　结构体成员的布局 
                              <P>　　很多编译器有“使结构体字，双字或四字对齐”的选项。但是，还是需要改善结构体成员的对齐，有些编译器可能分配给结构体成员空间的顺序与他们声明的不同。但是，有些编译器并不提供这些功能，或者效果不好。所以，要在付出最少代价的情况下实现最好的结构体和结构体成员对齐，建议采取这些方法： 

                              <P>　　按类型长度排序 
                              <P>　　把结构体的成员按照它们的类型长度排序，声明成员时把长的类型放在短的前面。 
                              <P>　　把结构体填充成最长类型长度的整倍数 
                              <P>　　把结构体填充成最长类型长度的整倍数。照这样，如果结构体的第一个成员对齐了，所有整个结构体自然也就对齐了。下面的例子演示了如何对结构体成员进行重新排序： 

                              <P>　　不好的代码，普通顺序 推荐的代码，新的顺序并手动填充了几个字节 
                              <P>struct<BR>{<BR>　　char a[5]；<BR>　　long 
                              k；<BR>　　double x；<BR>} 
                              baz；<BR>struct<BR>{<BR>　　double x；<BR>　　long 
                              k；<BR>　　char a[5]；<BR>char pad[7]；<BR>} baz； 
                              <P>　　这个规则同样适用于类的成员的布局。 
                              <P>　　按数据类型的长度排序本地变量 
                              <P>　　当编译器分配给本地变量空间时，它们的顺序和它们在源代码中声明的顺序一样，和上一条规则一样，应该把长的变量放在短的变量前面。如果第一个变量对齐了，其它变量就会连续的存放，而且不用填充字节自然就会对齐。有些编译器在分配变量时不会自动改变变量顺序，有些编译器不能产生4字节对齐的栈，所以4字节可能不对齐。下面这个例子演示了本地变量声明的重新排序： 

                              <P>　　不好的代码，普通顺序 推荐的代码，改进的顺序 
                              <P>short ga, gu, gi；<BR>long foo, bar；<BR>double 
                              x, y, z[3]；<BR>char a, b；<BR>float baz；<BR>double 
                              z[3]；<BR>double x, y；<BR>long foo, bar；<BR>float 
                              baz；<BR>short ga, gu, gi； 
                              <P>　　避免不必要的整数除法 
                              <P>　　整数除法是整数运算中最慢的，所以应该尽可能避免。一种可能减少整数除法的地方是连除，这里除法可以由乘法代替。这个替换的副作用是有可能在算乘积时会溢出，所以只能在一定范围的除法中使用。 

                              <P>　　不好的代码 推荐的代码 
                              <P>int i, j, k, m；<BR>m = i / j / k；<BR>int i, j, 
                              k, m；<BR>m = i / (j * k)； 
                              <P>　　把频繁使用的指针型参数拷贝到本地变量 
                              <P>　　避免在函数中频繁使用指针型参数指向的值。因为编译器不知道指针之间是否存在冲突，所以指针型参数往往不能被编译器优化。这样是数据不能被存放在寄存器中，而且明显地占用了内存带宽。注意，很多编译器有“假设不冲突”优化开关（在VC里必须手动添加编译器命令行/Oa或/Ow），这允许编译器假设两个不同的指针总是有不同的内容，这样就不用把指针型参数保存到本地变量。否则，请在函数一开始把指针指向的数据保存到本地变量。如果需要的话，在函数结束前拷贝回去。 
                              　　不好的代码 推荐的代码 
                              <P>?/ 假设 q != r<BR>void isqrt(unsigned long a, 
                              unsigned long* q, unsigned long* r)<BR>{<BR>　　*q = 
                              a；<BR>　　if (a &gt;； 0)<BR>　　{<BR>　　　　while (*q 
                              &gt;； (*r = a / *q))<BR>　　　　{<BR>　　　　　　*q = (*q + 
                              *r) &gt;；&gt;； 1；<BR>　　　　}<BR>　　}<BR>　　*r = a - *q 
                              * *q；<BR>}<BR>// 假设 q != r<BR>void isqrt(unsigned 
                              long a, unsigned long* q, unsigned long* 
                              r)<BR>{<BR>　　unsigned long qq, rr；<BR>　　qq = 
                              a；<BR>　　if (a &gt;； 0)<BR>　　{<BR>　　　　while (qq 
                              &gt;； (rr = a / qq))<BR>　　　　{<BR>　　　　　　qq = (qq + 
                              rr) &gt;；&gt;； 1；<BR>　　　　}<BR>　　}<BR>　　rr = a - qq 
                              * qq；<BR>　　*q = qq；<BR>　　*r = rr；<BR>} 
                              <P><BR>赋值与初始化<BR>先看看以下代码： 
                              <P>class CInt<BR>{<BR>　　int m_i； 
                              <P>public:<BR>　　CInt(int a = 0):m_i(a) { cout 
                              &lt;；&lt;； "；CInt"； &lt;；&lt;； endl； 
                              }<BR>　　~CInt() { cout &lt;；&lt;； "；~CInt"； 
                              &lt;；&lt;； endl； } 
                              <P>　　CInt operator + (const CInt&amp;； a) { return 
                              CInt(m_i + a.GetInt())； } 
                              <P>　　void SetInt(const int i)　　{ m_i = i； 
                              }<BR>　　int GetInt() const　　　　　　{ return m_i； 
                              }<BR>}；<BR>不好的代码 推荐的代码 <BR>void 
                              main()<BR>{<BR>　　CInt a, b, 
                              c；<BR>　　a.SetInt(1)；<BR>　　b.SetInt(2)；<BR>　　c = a 
                              + b；<BR>}<BR>void main()<BR>{<BR>　　CInt a(1), 
                              b(2)；<BR>　　CInt c(a + b)；<BR>} 
                              <P>　　这两段代码所作的事都一样，但那一个更好呢？看看输出结果就会发现，不好的代码输出了四个"；CInt"；和四个"；~CInt"；，而推荐的代码只输出三个。也就是说，第二个例子比第一个例子少生成一次临时对象。Why? 
                              请注意，第一个中的c用的是先声明再赋值的方法，第二个用的是初始化的方法，它们有本质的区别。第一个例子的"；c 
                              = a + b"；先生成一个临时对象用来保存a + 
                              b的值，再把该临时对象用位拷贝的方法给c赋值，然后临时对象被销毁。这个临时对象就是那个多出来的对象。第二个例子直接用拷贝构造函数的方法对c初始化，不产生临时对象。所以，尽量在需要使用一个对象时才声明，并用初始化的方法赋初值。 

                              <P>　　尽量使用成员初始化列表 
                              <P>　　在初始化类的成员时，尽量使用成员初始化列表而不是传统的赋值方式。 
                              <P>　　不好的代码 推荐的代码 
                              <P>籧lass CMyClass<BR>{<BR>　　string strName； 
                              <P>public:<BR>　　CMyClass(const string&amp;； 
                              str)；<BR>}； 
                              <P>CMyClass::CMyClass(const string&amp;； 
                              str)<BR>{<BR>　　strName = str；<BR>}<BR>class 
                              CMyClass<BR>{<BR>　　string strName；<BR>　　int i； 
                              <P>public:<BR>　　CMyClass(const string&amp;； 
                              str)；<BR>}； 
                              <P>CMyClass::CMyClass(const 
                              string&amp;；str)<BR>　　: strName(str)<BR>{<BR>} 
                              <P>　　不好的例子用的是赋值的方式。这样，strName会先被建立（调用了string的默认构造函数），再由参数str赋值。而推荐的例子用的是成员初始化列表，strName直接构造为str，少调用一次默认构造函数，还少了一些安全隐患。 
                              <BR><BR><BR></TD>
                          </TR>
                          </TBODY> 
                        </TABLE>
                      </TD>
                    </TR>
                    <TR> 
                      <TD height=35 width="100%"> 
                        <DIV align=center></DIV>
                      </TD>
                    </TR>
                    </TBODY> 
                  </TABLE>
                </TD></TR></TBODY>
			</TABLE>
			</TD></TR></TBODY>
		</TABLE>
	</TD></TR></TBODY>
</TABLE>
<TABLE align=center border=0 cellPadding=0 cellSpacing=0 width=750>
 <TBODY>
  <TR>
    <TD bgColor=#c1c1c1 height=1></TD>
  </TR>
 </TBODY>
</TABLE>


<TABLE align=center border=1 cellPadding=0 cellSpacing=1 
style="BORDER-COLLAPSE: collapse" width=550>
 <TBODY>
  <td  align=center>
      <div align="center">
        <p><a href=mailto:[e-mail] ><span class="body14black">mailto:[e-mail]</span></a><span class="body12red"> 
          &nbsp;&nbsp;&nbsp;&nbsp;热线电话：[phone]</span></p>
      </div>
    </td>
 </TBODY>
</TABLE>

</BODY></HTML>