模板类3

追加：如果函数模板参数的类型能够在传入参数中就确定下来的话，就可以直接省略<>

template<typename T>
int create_sql_expression(T *&p);

调用：

ObColumnExpression *c = NULL;

create_sql_expression(c);

如果模板函数的参数不能显示的确定下来，则需要在<>中指定；

template<typename T， typename T2>
int create_sql_expression(T *&p);

调用：

ObColumnExpression *c = NULL;

create_sql_expression<ObColumnExpression, ObSqlExpression>(c);

=======

（1）模板类对象申明时可以用父类类型，但是实际使用时可以用子类类型；

（2）如果将模板类对象作为函数参数，如果函数定义时不带模板参数的话，默认和调用者使用同一模板类型；如果只带<>，则使用默认模板类型；

 int assign(ObArray<Basic> &other)

 int assign2(ObArray &other)

 int assign3(ObArray<> &other)

//测试模板类对象的申明中用父类类型，是否可以存入子类类型对象
#include <stdio.h>
class Basic
{
public:
  Basic() {}
  virtual ~Basic() {}
  int print(int a)
  {
    a_ = a;
    printf("Basic output a=%d", a);
    return 0;
  }
  int print()
  {
    printf("Basic output a_=%d", a_);
  }
protected:
  int a_;
};


class Child : public Basic
{
public:
  Child() {}
  virtual ~Child() {}
  int print(int a)
  {
    a_ = a;
    b_ = a;
    printf("Child output a=%d", a);
    return 0;
  }
  int print()
  {
    printf("Child output a_=%d", a_);
  }
private:
  int b_;
};

class Other

{
public:
  int print(int a)
  {
    b_ = a;
    printf("Other output a=%d", a);
    return 0;
  }
  int print()
  {
    printf("Other output a_=%d", b_);
  }
private:
  int b_;
};
template<typename classT = Basic>
class ObArray
{
public:
  ObArray() {pos_ = 0;}
  int push_back(classT &value)
  {
    array_[pos_++] = value;
    return 0;
  }
  int pop(classT &value)
  {
    value = array_[pos_ -1];
    pos_--;
    return 0;
  }
  classT at(int index) {
    return array_[index];
  }
  int count()  {return pos_;}
  int assign3(ObArray<> &other)
  {
    for (int i = 0; i < other.count(); i++) {
      //push_back(other.at(i));
    }
    return 0;
  }
  int assign2(ObArray &other)
  {
    for (int i = 0; i < other.count(); i++) {
      //push_back(other.at(i));
    }
    return 0;
  }

int assign(ObArray<Basic> &other)
  {
    for (int i = 0; i < other.count(); i++) {
      //push_back(other.at(i));
    }
    return 0;
  }


private:
  int pos_;
  classT array_[10];
};


int main()
{
  ObArray<Basic> array;  //定义父类类型的模板容器
  Child c;
  c.print(10);
  array.push_back(c);  //插入一个子类类型的对象到容器中。
  Child cc;
  array.pop(cc);
  cc.print();
  array.push_back(c);
  array.push_back(cc);
  ObArray<Other> other_array;
  other_array.assign(array);
  //函数原型不指定模板参数类型的话，默认采用同一个模板参数类型
  other_array.assign2(array); //编译错误； int ObArray<classT>::assign2(ObArray<classT>&) [with classT = Other] no matching function for call to  //‘ObArray<Other>::assign2(ObArray<Basic>&)’

  other_array.assign3(array); //如果函数原型中参数带<>的话，参数类型带默认模板参数类型；
  return 0;
}