使用断点跟踪之后发现错误出在使用TQuery时执行open方法时，回追根源，得出以下反馈：

m_pqQuery -> SQL -> Add(  " Select * From Table1 Where Id = :PId  "  );
m_pqQuery -> ParamByName(  " PId "  ) -> AsInteger      =  某个int变量;

执行完这句之后，按正常情况，参数PId应该被赋予了一个整形值，但是Debug跟踪显示其值还是跟未赋值前是同样表示的未知值。所以在执行open方法时出错了。

如果我不是用该方法，直接把SQL语句写死：

m_pqQuery -> SQL -> Add(  " Select * From Table1 Where Id = 0  "  );

运行正常

或者用

char  sql[ 80 ];
int  n  =  某整形变量 ;
sprintf(sql, " Select * From Table1 Where Id = %d " ,n);
pqQuery -> SQL -> Add(sql);

也运行正常

查了下，原来给参数赋值的方法并没有错误，编译也能通过，况且以前该程序肯定是能正常运行的。。真是奇怪为什么在我这里就赋不上值。。调试了很久也没能找到原因，只好作罢，为了顺利运行，只能改为sprintf和直接连接字符串的方式。
在这里记上一笔，希望以后能够找到原因。。。

重载<<操作符
要重新定义<<操作符，以便将它和cout一起用来显示对象的内容，请定义下面的友元操作符函数：

ostream & operator << (ostream & os,const c_name & obj)
{
os << ;// display object contents
return os;
}

其中c_name是类名。如果该类提供了能够返回所需内容的公有方法，则可在操作符函数中使用这些方法，这样便不会将他们设置为友元函数了。

转换函数
要将单个值转换为类类型，需要创建原型如下所示的类构造函数：

c_name(type_name value);

其中c_name为类名，type_name是要转换的类型的名称。
要将类转换为其他类型，需要创建原型如下所示的类成员函数：

operator type_name();

虽然该函数没有声明返回类型，但应返回所需类型的值。
使用转换函数时要小心。可以在声明构造函数时使用关键字explicit，以防止它被用于隐式转换。

• 对于指向的内存是由new分配的所有类成员，都应在类的析构函数中对其使用delete，该操作符将释放分配的内存。
• 如果析构函数通过对指针类成员使用delete来释放内存，则每个构造函数都应当使用new来初始化指针，或将它设置为空指针。
• 构造函数中要么使用new[]，要么使用new，而不能混用。如果构造函数使用的是new[]，则析构函数应使用delete[]；如果构造函数使用的是new，则析构函数应适用delete。
• 应定义一个分配内存（而不是将指针指向已有内存）的复制构造函数。这样程序能够将类对象初始化为另一个对象。这种构造函数原型如下：
  className(const className &)
• 应定义一个重载赋值操作符的类成员函数，其函数定义如下（其中c_pointer是c_name的类成员，类型为指向type_name的指针）。下面的范例假设使用new[]来初始化变量c_pointer）：
  c_name & c_name::operator = (const c_name & cn)
  {
  if (this == & cn)
  return *this;
  
  delete [] c_pointer;
  // set size number of type_name units to be copyied
  c_pointer = new type_name[size];
  // then copy data pointed to by cn.c_pointer to
  // location pointed to by c_pointer
  
  return *this;
  }

本文对我前面几篇随笔中提到的问题也作出了一个总结，感觉很有必要记下来。
以上内容原文引用自参考书籍中内容。

参考书籍：C++PrimerPlus author:Stephen Prata

const   int  BUF  =   512  ;

class  JustTesting
{
     private :
        JustTesting( const   string   &  s  =   " Just Testing " , int  n  =   0 )
         {}  
         ~ JustTesting() {}
     public :
    
} ;

int  main()
{
     char   *  buffer  =   new   char  [BUF];

    JustTesting  * pc1, * pc2, * pc3, * pc4;

    pc1  =   new  (buffer) JustTesting;
    pc2  =   new  JustTesting(  "  Heap1  "  ,  20  );

    pc3  =   new  (buffer  +   sizeof  (JustTesting)) JustTesting( " Bad Idea " , 6 );   //  此处用一个JustTesging对象大小的偏移量避免pc3与pc1占用同一块内存，因为如果类动态的为其成员分配内存，占用同一内存将会产生问题。 
    pc4  =   new  JustTesting( " Heap2 " , 10 ) 

    

    delete pc2;
    delete pc4;
    delete [] buffer;
     return   0 ;
}

以上代码片断中，pc1和pc3为布局new操作符来分配内存，而pc2和pc4为常规new操作符来分配内存 。
对于常规new操作符分配的内存，可以直接使用：delete pc2; 这样的语句操作来释放内存。

而对于布局new操作符分配的内存就不能这样做：delete pc1;

因为pc1和pc3并没有直接收到new操作符返回的地址，而是由布局操作符指向了buffer的地址，new/delete系统知道已分配的512字节块buffer，但对布局new操作符对该内存块做了何种处理一无所知。
另一方面，buffer的地址是用new []初始化的，因此必须使用delete[]而不是delete。
注意：即使buffer是使用new而不是new[]初始化的，delete pc1 也将释放buffer，而不是pc1。

以上的代码确实释放了buffer：delete [] buffer;
但是由此产生了新的问题，它没有为布局new操作符在该内存块中创建的对象调用析构函数，我们只需要在析构函数中放入一段显示语句就可以清楚的看到，程序并没有销毁“JustTesting”和“Bad Idea”，也就是pc1和pc3指向的对象。
那么这里就需要我们显式的为布局new操作符创建的对象调用析构函数。正常情况下将自动调用析构函数，这是需要显示调用析构函数的少数几种情况之一。
显式调用析构函数时，必须指定要销毁的对象。由于有指向对象的指针，因此可以这样写：

把这段代码放到delete [] buffer;之前，这段程序才算完整无错。

参考书籍：C++PrimerPlus author:Stephen Prata

• 如果在构造函数中使用new来初始化指针成员，则应在析构函数中使用delete。
• new和delete必须相互兼容。new对应于delete，new[]对应于delete[]。
• 如果有多个构造函数，则必须以相同的方式使用new，要么都带中括号，要么都不带。因为只有一个析构函数，因此所有的构造函数都必须与它兼容。不过可以在一个构造函数中使用new来初始化指针，而在另外一个构造函数中将指针初始化为空（Null或0），这是因为delete（无论是带中括号还是不带中括号）可以用于空指针。

class  StringBad
{
     private :
         char   *  str;
         int  len;
         
     public :
        StringBad( const   char   *  s);
        StringBad();
         ~ StringBad();
        
} ;

在构造函数和析构函数定义当中有如下定义：

StringBad::StringBad( const   char   *  s)
{
    len  =  std::strlen(s);
    str  =   new   char  [len  +   1 ];
    
}  

StringBad::StringBad()
{
    len  =   4  ;
    str  =   new   char [ 4 ];
    
}  

StringBad:: ~ StringBad()
{
    
    delete [] str;
}

那么在程序当中如果有以下代码：

StringBad sports( " Spinach Leaves Bow1 for bollars " );
StringBad sailor  =  sports;

以上的第二条初始化语句将会调用什么构造函数？记住，这种形式的初始化等效于下面的语句：

StringBad sailor  =  StringBad(sports);

因为sports的类型为StringBad，因此相应的构造函数原型应该如下：

StringBad( const  StringBad  & );

当我们使用一个对象来初始化另一个对象时，编译器将自动生成上述构造函数（称为复制构造函数，因为它创建对象的一个副本）。
现在我们不妨总结一下所谓的隐式成员函数，即C++自动提供了以下这些成员函数：

• 默认构造函数，如果没有定义构造函数。
• 复制构造函数，如果没有定义。
• 赋值操作符，如果没有定义。
• 默认析构函数，如果没有定义。
• 地址操作符，如果没有定义。

现在我们来看看我们没有定义复制构造函数的情况下调用隐式复制构造函数将会出现什么情况。
从构造函数定义的代码片断可以看到，当中使用new操作符初始化了一个指针str，而隐式的复制构造函数是按值进行复制的，那么对于指针str，将会进行如下复制：

sailor.str  =  sports.str;

这里复制的不是字符串，而是一个指向字符串的指针！也就是说，我们将得到两个指向同一个字符串的指针！由此会产生的问题将不言而喻。当其中一个对象调用了析构函数之后，其str指向的内存将被释放，这个时候我们如果调用另一个对象，其str指向的地址数据会是什么？很明显将会出现不可预料的结果。

所以由此可见，如果类中包含了使用new初始化的指针成员，应当定义一个复制构造函数，以复制指向的数据，而不是指针，这被称为深度复制。因为默认的浅复制（或成为成员复制）仅浅浅的赋值指针信息。

我们再看以下代码片断，我们稍做修改：

StringBad headline1( " Celery Stalks at Midnight " );
StringBad knot;
knot  =  headline1;

这里的最后一行将与以上例子有所区别，现在是将已有对象赋给另一个已有对象，这将会采取其他操作，即使用重载的赋值操作符。（我们需要知道的是：初始化总是会调用复制构造函数，而使用=操作符时也可能调用赋值操作符）因为C++允许对象赋值，这是通过自动为类重载赋值操作符实现的。其原型如下：

Class_name  &  Class_name:: operator   =  ( const  Class_name  & );

它接受并返回一个指向类对象的引用。
与隐式的复制构造函数一样，隐式的对象赋值操作符也会产生同样的问题，即包含了使用new初始化的指针成员时，只会采用浅复制。所以我们需要使用同样的解决办法，即定义一个重载的赋值操作符来实现深度复制。

所以综上所述，如果类中包含了使用new初始化的指针成员，我们应该显式定义一个复制构造函数和一个重载的赋值操作符来实现其深度复制，避免由此带来的成员复制问题

参考书籍：C++PrimerPlus author:Stephen Prata