[c++]cout의 객체반환에 대해서

함수에 인자를 전달하는 방식과는 상관이 없는 것 같습니다.
위의 설명대로라면...

cout << 'a' << 'b' << 'c';
출력 : cba

결과가 위처럼 되야할 것입니다.

질문된 코드를 다음과 같이 바꿀 수 있습니다.

cout.operator<<("update is ").operator<<(update).operator<<(" and address update is "). 
       operator<<( &update).operator<<(endl). 
       operator<<("*p_update is ").operator<<(*p_update).operator<<(" and address *p_update is ") 
       operator<<(p_update).operator<<(endl).
       operator<<("++p_update is ").operator<<(++*p_update).operator<<(endl); 

즉 cout 객체의 함수 operator<<() 에 인자 하나씩만 전달해서 호출합니다.
따라서 실행 순서는

cout.operator<<("update is ")(1)
.operator<<(update)(2)
.operator<<(" and address update is ")(3)
.operator<<( &update)(4)
.operator<<(endl)(5)
.operator<<("*p_update is ")(6)
.operator<<(*p_update)(7)
.operator<<(" and address *p_update is ")(8)
.operator<<(p_update)(9)
.operator<<(endl)(10)
.operator<<("++p_update is ")(11)
.operator<<(++*p_update)(12)
.operator<<(endl);(13) 

입니다. 그런데 출력이 왜 그렇게 나올까요... cout 은 바로 출력하지 않고 출력 버퍼에 값을 보냅니다.. 그래서 그런 것이 아닌가요? 출력 버퍼에서 변수는 변수의 주소를 가지고 있으므로 마지막에 (12) 번 호출에서 값이 바뀌면 그 값이 그대로 찍히는 것 같습니다.

(먼저 c가 저장된다는 의미를 << 'c' 멤버 함수가 먼저 호출되는 것으로 이해했습니다)
pyj200 님의 말을 따르면 C++ 언어의 멤버 함수 호출 순서가 뒤에서부터 왼쪽으로란 뜻이 됩니다. c 가 먼저 저장될려면 << 'c' 멤버 함수가 먼저 호출 되어 호출 스택에 먼저 Push 되어야 합니다.

#include <iostream.h> 

class Print
{
private:
	int num;
public:
	Print() : num(0) {}
	Print& Print1(void) { cout << num; return *this; }
	Print& Print2(void) { cout << ++num; return *this; }
	Print& Print3(void) { cout << ++num; return *this; }
};

위의 클래스를 예로 들면...

int main() 
{ 
   c.Print1().Print2().Print3();
   cout << flush;
   return 0; 
}

제가 이해한 것을 가정하에 pyj200 님의 말을 따르면 코드의 출력 결과는 122 이어야 합니다. 하지만 출력 결과는 012 입니다.

제가 잘 모르는 것일 수도 있으니 c 가 어떻게 먼저 저장이 되는지 자세히 알려주세요^^

http://khdp.org/docs/common_doc/shellcode만들기_0912.txt

좀 다른 분야이기는 하지만 이 문서를 한번 보시면 도움이 될것 같습니다.......

전 곡쓰러 가야 합니다. =3=3=3=3 내일부터 다작모드로 들어가기로 했거든요. 게임음악을 위해 =3=3

하루에 두곡씩 쓸 계획입니다.

바로 글을 다셨네요..^^;
전 게임 프로그래밍에 관심만 많은 넘인데...-_-;;;
멋진 게임음악 만드시길 바랍니다.^^

C Calling Convention 이라고 하는 C에서 함수 호출시의 특성때문에

그렇습니다.

- advanced -

인수가 필요한 멤버함수를 중첩해서 쓰는 경우
GCC 이건 어떤 컴파일러건 매개변수를 몽땅 stack 에 쌓아 놓습니다.

int i=10;
int j=20;
cout<<(5+(i*j+(30-j)*2)/3)<<endl;

위 코드의 경우 컴파일러가
(5+(i*j+(30-j)*2)/3) 을 계산하기 위해
각 수를 모두 스택에 넣어두고 계산합니다.(5,i,j,30,j,2,3)
같은 원리로 인수가 필요한 멤버함수를 중첩해서 쓰는 경우도
마찬가지이죠

처음 생각으로는 인수가 필요한 멤버함수를 중첩해서 쓸 때
그냥 순서대로 호출하면 될 것이 아니냐고 할 수도 있는데
위 코드 "cout<<(5+(i*j+(30-j)*2)/3)<<endl;" 과 같이
멤버함수를 중첩해서 썼더라도 C++ 에서 한 개의 명령을 구분하는
문자 ";" 을 만나기 전까지 나타나는 모든 인수를 스택에 저장해 놓고
한 번에 계산한다고 생각하시기 바랍니다.
그 이유는 "cout<<(5+(i*j+(30-j)*2)/3)<<endl;" 에서처럼
왜 C++ 은 각 수(앞에서 부터 5,i,j,30 등등) 를 스택에 먼저 저장하고
한 번에 계산하는지에 대한 답과 동일합니다.

주의하실 점은

int i=0;
cout<<(--i)<<i<<(++i)<<(++i)<<(i+100)<<endl;

의 경우
차례대로 (--i,i,++i,++i,i+100) 에 해당하는 수를 스택에 저장할 거라고 생각하지만
꼭 그렇지가 않은 것이
VC++ 의 경우 인수의 메모리 주소 공간이 같을 경우
두 번 저장하지 않습니다.

따라서 VC++ 에서는
(--i,i,++i,++i,i+100) 이 아니고
순서대로 --i, i, ++i, ++i 을 계산한 그 수 i 와 i+100 만 스택에 저장합니다.
즉 (최종 변수 i , i+100) 이렇게 2 개의 값만 스택에 저장하는 것입니다.

이전 글에서도 얘기했지만 이런 것은 어느 쪽이든
C++ 사양에서 정해지지 않은 것이므로
이식성이 없다는 점 주의하세요

전역연산자함수라고 해서 예외가 되지는 않습니다.

akbar 씨의 답변에 멤버함수라고 이야기하시는데 그렇다면 연산자함수만이 아니라 일반적인 멤버함수도 마찬가지라는 것인가요?
왜인지 일반 전역함수도 마찬가지라는 답변이 나올 것 같기에 더욱 의문입니다.

음... 제가 sequence point 에 대해 잘못 알고 있는 것 같네요.
제대로 공부안한 티가... (T.T)

akbar 씨의 글을 보면 언제나 C++ 의 새로운 가능성을 보는 것 같습니다.
솔직히 이해를 못하는 경우가 허다합니다만... -_-

와.. 정말 많은 것을 배우고 갑니다.
전 기본을 다시 딱아야 되겠네요^^

요게 무슨 뜻인지 몰라서 vc++ 7.1.3091 과 gcc 3.3.2 에서
테스트 해 봤는데요..

테스트 코드는 이렇구요..

int i=0;
cout << (i=i+1) << (i=i+2) << (i=i+3) ;

결과 값이...

vc++은 계산을 다 해서 i 값을 만들어 놓고...
(그 과정에서 i=6이 됩니다.)
<< operator를 세번 호출합니다.

	cout << (i=i+1) <<  (i=i+2) <<  (i=i+3) <<endl;
0041BD65  mov         eax,dword ptr [i] 
0041BD68  add         eax,3 
0041BD6B  mov         dword ptr [i],eax 
0041BD6E  mov         ecx,dword ptr [i] 
0041BD71  add         ecx,2 
0041BD74  mov         dword ptr [i],ecx 
0041BD77  mov         edx,dword ptr [i] 
0041BD7A  add         edx,1 
0041BD7D  mov         dword ptr [i],edx 
0041BD80  push        offset std::endl (41A0B3h) 
0041BD85  mov         eax,dword ptr [i] 
0041BD88  push        eax  
0041BD89  mov         ecx,dword ptr [i] 
0041BD8C  push        ecx  
0041BD8D  mov         edx,dword ptr [i] 
0041BD90  push        edx  
0041BD91  mov         ecx,offset std::cout (457668h) 
0041BD96  call        std::basic_ostream<char,std::char_traits<char> >::operator<< (4195D2h) 
0041BD9B  mov         ecx,eax 
0041BD9D  call        std::basic_ostream<char,std::char_traits<char> >::operator<< (4195D2h) 
0041BDA2  mov         ecx,eax 
0041BDA4  call        std::basic_ostream<char,std::char_traits<char> >::operator<< (4195D2h) 
0041BDA9  mov         ecx,eax 
0041BDAB  call        std::basic_ostream<char,std::char_traits<char> >::operator<< (41A0B8h) 

gcc 3.3.2에서는 왼쪽부터 순서대로 << operator를 실행하네요...

0x08048624 <main+16>:   movl   $0x0,0xfffffffc(%ebp)
0x0804862b <main+23>:   lea    0xfffffffc(%ebp),%eax
0x0804862e <main+26>:   incl   (%eax)
0x08048630 <main+28>:   mov    0xfffffffc(%ebp),%eax
0x08048633 <main+31>:   mov    %eax,0x4(%esp,1)
0x08048637 <main+35>:   movl   $0x80499e8,(%esp,1)
0x0804863e <main+42>:   call   0x8048524
0x08048643 <main+47>:   mov    %eax,%edx
0x08048645 <main+49>:   lea    0xfffffffc(%ebp),%eax
0x08048648 <main+52>:   addl   $0x2,(%eax)
0x0804864b <main+55>:   mov    0xfffffffc(%ebp),%eax
0x0804864e <main+58>:   mov    %eax,0x4(%esp,1)
0x08048652 <main+62>:   mov    %edx,(%esp,1)
0x08048655 <main+65>:   call   0x8048524
0x0804865a <main+70>:   mov    %eax,%edx
0x0804865c <main+72>:   lea    0xfffffffc(%ebp),%eax
0x0804865f <main+75>:   addl   $0x3,(%eax)
0x08048662 <main+78>:   mov    0xfffffffc(%ebp),%eax
0x08048665 <main+81>:   mov    %eax,0x4(%esp,1)
0x08048669 <main+85>:   mov    %edx,(%esp,1)
0x0804866c <main+88>:   call   0x8048524

이걸 보고 생각한건데...
멤버연산자가 중첩된경우 호출 순서를 명시하지 않았다는 말이 이것처럼...
호출 순서가 순차적일수도 있고, 한번에 몰아서(-_-)할 수도 있다는 뜻인것 같습니다.