C++函数模板递归一二维数组动态分配存储空间实例1

C++函数模板递归一二维数组动态分配存储空间实例1

//baseCplusplus1.h
//C++函数模板递归一二维数组动态分配存储空间实例1
#include
#include    //std::cin>>  ; std::cout<<

#include
#include

int Abc(int a,int b,int c);         //定义Abc(int,int,int)函数
float Abc(float a,float b,float c); //定义Abc(float,float,float)函数
template                   //定义一个Abc模板函数(传值参数a,b,c)
T Abc(T a,T b,T c)
{
 std::cout<<"Abc(T)=";
 return a+b+b*c+(a+b-c)/(a+b)+4;
};
template                   //定义一个Abc模板函数(引用参数a,b,c)
T Abc_Ref(T& a,T& b,T& c)
{
 std::cout<<"Abc(T&)=";
 return a+b+b*c+(a+b-c)/(a+b)+4;
};
template                   //定义一个Abc模板函数(常量引用参数a,b,c)
T Abc_constRef(const T& a,const T& b,const T& c)
{
 std::cout<<"Abc(const T&)=";
 return a+b+b*c+(a+b-c)/(a+b)+4;
};
template   //定义一个Abc模板函数(常量引用参数a,b,c)更通用的一个版本
Ta Abc_paramRef(const Ta& a,const Tb& b,const Tc& c)
{
 std::cout<<"Abc(const Tabc&)=";
 return a+b+b*c+(a+b-c)/(a+b)+4;
};

template
T& X(int i,T& z)  //定义一个返回类型为引用类型
{
 return z;
}
template
const T& X(int i,T& z) //定义一个返回类型为常量引用类型
{
 return  const z;
}
//----
int Factorial(int n);  //定义一个递归函数(直接递归)
//----
template
T Sum(T a[],int n);    //定义一个模板函数S u m(累加)

template
T Rsum(T a[],int n);   //定义一个模板函数S u m(递归)

//-------------
template
void Perm(T list[],int k,int m);  //递归函数生成排列

template
inline void Swap(T& a,T& b);  //交换函数

template
bool Make2DArray(T ** &x,int rows,int cols)  //创建一个二维数组
{
 try
 {
  x=new T * [rows];  //创建行指针
  for(int i=0;i  {
   x[i]=new int[cols];
  }
  return true;
 }
 catch(...)
 {
  return false;
 }
}
template
void Delete2DArray(T ** &x,int rows)  //删除二维数组
{
 for(int i=0;i  delete [] x[i];  // 释放为每一行所分配的空间
 delete [] x;  //删除行指针
 x=0;
}

//-----------------------------------
//-----------------------------------
int Abc(int a,int b,int c)
{
 std::cout<<"Abc(int)=";
 return a+b+b*c+(a+b-c)/(a+b)+4;
}

float Abc(float a,float b,float c)
{
 std::cout<<"Abc(float)=";
 return a+b+b*c+(a+b-c)/(a+b)+4;
}

//定义一个返回类型为引用类型(直接递归)
int Factorial(int n)
{
 if(n<=1) return 1;
 else return n*Factorial(n-1);
}

template
T Sum(T a[],int n)
{
 T tsum=0;
 for(int i=0;i {
  tsum+=a[i];
 }
 return tsum;
}

template
T Rsum(T a[],int n)
{
 if(n>0)
  return Rsum(a,n-1)+a[n-1];
 return 0;
}

template
void Perm(T list[],int k,int m)  //递归函数生成排列
{
 int i;
 if(k==m)
 {
  for(int i=0;i<=m;i++)
  {
   cout<  }
  cout< }
 else
 {
  for(i=k;i<=m;i++)
  {
   Swap(list[k],list[i]);
   Perm(list,k+1,m);
   Swap(list[k],list[i]);
  }
 }
}

template
inline void Swap(T& a,T& b)  //交换函数
{
 T temp=a;a=b;b=temp;
}

//------------------------
// Win32Console.cpp : 定义控制台应用程序的入口点。
//C++函数模板一二维数组动态分配存储空间实例

#include "stdafx.h"
#include "baseCplusplus1.h";

int _tmain(int argc, _TCHAR* argv[])
{
 int rbc=Abc(2,3,4);
 std::cout<<"Abc(2,3,4)="<

 float a,b,c;
 a=2.5;b=3.0;c=4.0;
 float rbc_f=Abc(a,b,c);
 std::cout<<"Abc(2.5,3,4)="<

 double ad,bd,cd;
 ad=2.5;bd=3.1;cd=4.2;

 double rbc_d=Abc_Ref(ad,bd,cd);
 std::cout<<"Abc(2.5,3.1,4.2)="<

 rbc_d=Abc_paramRef(ad,bd,cd);
 std::cout<<"Abc(2.5,3.1,4.2)="<

 int r_f=Factorial(3);
 std::cout<<"Factorial(3)="<

 //动态存储分配  一维整型数组
 int *y=new int;
 *y=10;
 //-
 int *yy=new int(10);
 //-
 int *yyy;
 yyy=new int(10);

 //----   一维浮点数组
 try
 {
  //动态分配存储空间
  float *f=new float[5];
  f[0]=0;
  f[1]=1;
  f[2]=2;
  for(int i=0;i<5;i++) f[i]=i;
  for(int i=0;i<5;i++) std::cout<<"f["<

  char d[7][5];
  //为二维数据动态分配空间(行)
  int n=7;
  char (*c)[5]; 
  n=n+5;
  c=new char[n][5];

  //--为二维数据动态分配空间(行,列)
  int **x;
  Make2DArray(x,7,5);
  for(int i=0;i<7;i++)
   for(int j=0;j<5;j++)
   {
    x[i][j]=i+j; std::cout<<"x["<   }

  //--
  //释放存储空间
  delete y;
  delete yy;
  delete yyy;
  delete [] f;
  
  Delete2DArray(x,7);
  
 }
 catch(...)
 {
  std::cout<<"Out of Memory"<  exit(1);
 }

 //暂停操作
 char str;
 std::cin>>str;
 //程序结束
 return 0;
}