#include <iostream>- M1 |4 u$ P: v; d3 c. }$ K0 H& ~
+ P; l3 s1 Y7 f6 n+ j4 |
void f(int i, int j) { std::cout<<i<<' '<<j; }4 Y0 ]1 c2 A1 Z/ l4 a) `- d! X" }
1 D7 `3 W6 P% c
int g(int i) {, F. a4 H' `, \% Y( P
     return i;
5 R9 B9 f5 f# E+ `- g2 e3 ]}1 U* C2 f4 v1 y, O' M! p0 T
int main() {* F, B$ x1 ^7 d- N. b
    int a(1), b(2);
4 x; W' ^+ H- l* g6 M: f    f(a+b, ++b);! U" Y" @6 G0 `$ }/ i1 M6 [; L3 Y
    std::cout<<"\n";
* e  D  z9 m/ W, T# U4 ]% e    a = 1, b = 2;, I/ M' D) H5 }% m+ Y' Q9 q
    f(g(a+b), ++b);
6 q! \& O# ?! A) Q    system("pause");
% |+ t1 \, L( s* l1 {3 j}. _- `! R+ O% n2 s# q: g* G, ?  N
结果是:
0 y( N  A6 O3 G& k% q8 ?4  3
- A! W' }) C6 t- y, }3  38 Y$ E( R9 b6 B6 J
是说明参数中的表达式是交叉计算的？) D6 ^" o; ~2 j8 }
编译器是gcc，我觉得对这个参数的计算好像是"分层"的， 是吗？　　　　　　

不是很明白楼主说的交叉和分层计算是什么意思，不过编译器的灵活性毕竟是有局限性的，如果拿研究宇宙的精神去研究这个，有些小题大做了。如果楼主有兴趣的话，不妨去研究一下gcc各版本的区别，这貌似还比较有用的说。　　　　　　

交叉, 可能是我翻译的不对, 是interleaved, 分层是我自己编的.
$ U7 y7 d4 x; ^* S只是觉得gcc对于函数参数和表达式的顺序是好的, 如下:
" J( U- i9 C2 x4 T$ Yf(auto_ptr<A>(new A), auto_ptr<B>(new B));+ T7 Q7 H9 D0 k7 U0 Q, V- o
gcc是不会造成内存泄漏的, 所以想知道gcc对于函数参数的标准.　　　　　　

我觉得你举的例子是有关堆栈的，压栈和出栈的顺序，而不是你所说的参数的顺序。　　　　　　

...我曾经大致考察了一下，简单的如printf函数，在gcc和VC6下面就不同，取决于各家编译器吧，不过从右开始的比较多。　　　　　　

楼主的做法应该避免，这不是好习惯。
0 i, g* k5 q7 ~－－－－－－－－－－－－－－－－－－－－& e# J6 V9 d8 ~& d; X. R
http://blog.csdn.net/fengyv　　　　　　

[QUOTE=Asongala]交叉, 可能是我翻译的不对, 是interleaved, 分层是我自己编的.
# p' Y4 p" r, f2 n. e) E只是觉得gcc对于函数参数和表达式的顺序是好的, 如下:) T+ J) h4 ^( C' E1 E1 C* ?4 b
f(auto_ptr<A>(new A), auto_ptr<B>(new B));
( n1 c7 j  s8 B$ ^gcc是不会造成内存泄漏的, 所以想知道gcc对于函数参数的标准.[/QUOTE]
% j7 P  f# ?. o  l" W* `建议看些比较深入的 C++ 资料或者阅读一下 C++ 的 ISO 标准. 自己写些小的程序探索一下也可以　　　　　　

在看完 [url="http://www.gotw.ca/gotw/056.htm"]http://www.gotw.ca/gotw/056.htm[/url] 后，在gcc下测试了一下& K- H9 }9 l# {6 Q
f( auto_ptr<T1>( new T1 ), auto_ptr<T2>( new T2 ) );4 s8 c! [. n. q% e- b9 n# y0 m
是不会造成内存泄漏的，所以问的。- Z4 M: C* u% D! p% x) K2 J

) B9 ?' C/ b1 v3 P2 ~觉得是如果函数调用中有new表达式，其他的参数或其中的表达式必须是nothrow的。　　　　　　

这就是 auto_ptr 的“神奇”和“方便”所在 　　　　　　

还是请帮忙看一下那篇文章，是More Exceptional C++ 的一章。: \: x5 b. h" Q; |5 o
以下是测试：3 i4 b; P6 a8 _  }

* n, T, _* a: A/ o5 {#include <iostream>
% b/ B3 {9 y! u9 m. k( L#include <memory>+ S" P: P) Q( d( ^9 a; M
class A {/ R9 [+ z; w- l( v/ T* A
public:
4 F" Y8 G5 m+ J- H, T+ l  kA() { std::cout<<"A constructor"<<"\n"; throw 1; }
: L0 Y$ V* K# S* ]' T$ b3 @};. N* q5 N# x: R
class B {
; `" K/ w' r2 a# z$ X7 dpublic:
' Z2 B+ f' z5 a. @0 [% ]: l; iB() { std::cout<<"B constructor"<<"\n"; }
- o* c5 ~: e  Q- Z/ L~B() { std::cout<<"~B()"<<"\n"; }
# c: o3 D* T! x/ \& V};
, X0 V' B- O7 ~8 J$ N8 fvoid f(std::auto_ptr<A> ap, std::auto_ptr<B> bp) { }0 N0 Q1 ]7 W8 e; ^) I' V8 S( g4 f
int main() {* ], ^& O# {8 |+ c; J9 K
try{
) o" {  C. L1 A3 [f(std::auto_ptr<A>(new A), std::auto_ptr<B>(new B));
# A: V# w7 a2 d  @8 `# R}
0 @: W' c- N4 k0 t6 Ucatch(...) { }
. d2 N# J2 j3 x+ j  {* [system("pause");8 b  V% t; g9 J
}
! g" ?6 I8 }4 A/ @+ E( W+ ?所以是先生成的auto_ptr<B>对象, 然后new A 。6 M$ O- x* @. N7 Q
是标准对于效率的灵活和gcc的严谨。