CSDN博客

img RedStar81

临时对象研究手记

发表于2003/3/27 11:03:00  1258人阅读

  临时对象,在C++表层和内部实施非常至多.
  然而由于它特定的性质,很多行为不为人所知.
  在Andrei发起的编译时编程中,它是很有价值的东东....
  下面我们通过实验来求证一些行为,
  以便更好的利用它:

#include <iostream>
#include <stdio.h>

using namespace std;

class x;
void fook__(x _in);

class x{
public:
x(int _param):m_Idata(_param){}
~x() { cout<<" I am des ..now.."<<" "<<m_Idata<<endl; }
void print(){ cout<<" Signal..."<<endl; }
public:
int m_Idata;
};

void fook(x _in)
{
_in.print();
cout<<" "<<_in.m_Idata<<endl;
}

void fook_()
{
x(100);
fook__(x(1200));
}

void fook__(x _in)
{
_in.print();
x(1000).print();
}

int main(){

//++++++++++++++++++++++++++
int _Idata;
cout<<" "<<&_Idata<<endl;
cout<<" "<<&x(10)<<endl;

//+++++++++++++++++++++++

{
  x(10);   // [1]
};

//+++++++++++++++++++++++

{
x a(199);
};
//+++++++++++++++++++++++

cout<<"------------------------"<<endl;

//+++++++++++++++++++++++

fook_();                  //这个地方很重要

//++++++++++++++++++++++

cout<<"-----------------------"<<endl;

//+++++++++++++++++++++++

x(10);     // [2]

//+++++++++++++++++++++++
cout<<"----------------------"<<endl;

fook(x(100));  //[3]

//+++++++++++++++++++++++
//
// 从上面可看出:
//         1.“即时的”临时对象(对比于copy等性质的)的生命期到(;)为止...
//         2.在涉及临时对象的一切[物和事,无论这些物和事深入多少层,
//           或者某一步之后变毫无关系和作用......]
//           结束,原临时对象(上面的函数传入是copy的)才会销毁.
//           而“即时的”临时对象的生命期是最短的...............
//                                                    
// 我对这种现象的看法:
//           1. 编译器识别临时对象,并像对待普通变量一样为它分配空间,
//              然而在编译期,编译器了解它所有的行为和数据被使用情况
//              在特定时机,调用析构...但是这里的析构不是堆对象那种
//              意义,它不会继续调用::operator delete(,)来实行所谓的
//              释放空间,那事实上也"没用"那只对堆对象有效...这样
//              即使调用了析构,你看到的“意想",析构并不代表一定跟
//              内存有关.
//               对于栈上
//              的临时对象那没必要(如果你的对象不够复杂)....
//              而对于堆上的临时对象,它没有"句柄" ,你永远释放
//              不了它...想管也管不了....
//               那么你建一个,Memory Leak 便重一点........
//               [谨防这种行为.............]
//              除非delete x("I am programming....");
//---------------------------你看看这个片段---------------------------
/*
#include <iostream>
#include <stdio.h>

using namespace std;

class x{
public:
  char* _chr_ptr;
  x(char* _in):_chr_ptr(_in){}
  //
  //  char* _chr_ptr;
  //x(char* _in):_chr_ptr(new char[strlen(_in)+1]){
  //                            strcpy(_chr_ptr,_in);
  //}
  //                再试一试这个...........[2]
  //
  ~x(){ delete _chr_ptr;   //注意这个地方 ,在连接栈上的数据时,没作用
   cout<<_chr_ptr<<endl;   //而连接堆上的数据时,此处会有问题.
   cout<<this<<endl;       //注意
  }
};

int main(){
x("I am programming...");  //注意这个临时对象
getchar();              //如果你使用new x("I am programming...")
return 1;               //会出问题的......再组合[2],再试一试...
                        //你试一试: new x("I am programming....")和
                        //       delete x("I am programmin......")    
}
*/
//              
//              你回头,,,,,再想象建立在栈上的对象......
//
//+++++++++++++++++++++++
//
//        总结:一切云开雾散,只是编译器是怎样怎样控制临时对象交错时的
//               生命期管理,依然求索......
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


getchar();
return 1;
}


----------------------------------------------------------------------
                    不要认为分析这个没什么价值
                    请看一精致的程式:
                    临时对象解决多线程的问题
               ----------------------------------------
          programme1:
          class Widget
          {
           ...
           void Lock();  //进入临界区
           void Unlock(); //退出临界区
           //这个地方的临界建立,须利用系统函数,简略之.....
          };
       
          programme2:
          template <class T>
          class LockingProxy
          {
            public:
            LockingProxy(T* pObj) : pointee_ (pObj)
            { pointee_->Lock(); }
            //    在临时对象构造是就锁定
            //    weight对象(临界区).
            ~LockingProxy() { pointee_->Unlock(); }
            //           
            //   在临时对象销毁时,退出临界区.
            //
            T* operator->() const
            { return pointee_; }
            //
            //  这里重载->运算符.将对临时对象的方法执行
            //  请求转交给weight对象
            //
            private:
            LockingProxy& operator=(const LockingProxy&);
            T* pointee_;
         };

         programme3:
         template <class T>
         class SmartPtr
         {
            ...
            LockingProxy<T> operator->() const
            { return LockingProxy<T>(pointee_); }
            //
            //  核心就在这里:产生临时对象
            //  LockingProxy<T>(pointee_)
            private:  sT* pointee_;
         };

         Programme4.
         SmartPtr<Widget> sp = ...;
         sp->DoSomething();       //##1
--------------------------------------------
 
   事实上,很多地方的临时对象是值得发掘的...
   譬如:const x fook(const x& _in);
         cout<<x.function<<enld;
   关键在于临时对象生命期和生命期交错的管理.

------------------------------------------------------------------- 
               声明:上面的是本人通过程式实验的结果
                      有问题或知之甚详者,
                      请教:81_redstar@163.com
------------------------------------------------------------------

阅读全文
0 0

相关文章推荐

img
取 消
img