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

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

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

#include <excpt.h>
#include <exception>

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

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

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

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

template<class T>
bool Make2DArray(T ** &x,int rows,int cols) //创建一个二维数组
{
try
{
x=new T * [rows]; //创建行指针
for(int i=0;i<rows;i++)
{
x[i]=new int[cols];
}
return true;
}
catch(...)
{
return false;
}
}
template<class T>
void Delete2DArray(T ** &x,int rows) //删除二维数组
{
for(int i=0;i<rows;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<class T>
T Sum(T a[],int n)
{
T tsum=0;
for(int i=0;i<n;i++)
{
tsum+=a[i];
}
return tsum;
}

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

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

template<class T>
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)="<<rbc<<"/n";

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)="<<rbc_f<<"/n";

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<<"/n";

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

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

//动态存储分配 一维整型数组
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["<<i<<"]"<<f[i]<<"/n";

char d[7][5];
//为二维数据动态分配空间(行)
int n=7;
char (*c)[5];
n=n+5;
c=new char
[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["<<i<<"]["<<j<<"]"<<x[i][j]<<"/n";
}

//--
//释放存储空间
delete y;
delete yy;
delete yyy;
delete [] f;

Delete2DArray(x,7);

}
catch(...)
{
std::cout<<"Out of Memory"<<std::endl;
exit(1);
}

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