写的我好累，分给我吧
#include<iostreamh>
#include<iomaniph>
template <class T>
class Array
{
T set;
int n;
public:
Array(T data,int i){set=data;n=i;}
~Array(){}
void sort(); // 排序
int seek(T key); // 查找指定的元素
T sum(); // 求和
void disp(); // 显示所有的元素
};
template<class T>
void Array<T>::sort()
{
int i,j;
T temp;
for(i=1;i<n;i++)
for(j=n-1;j>=i;j--)
if(set[j-1]>set[j])
{
temp=set[j-1];set[j-1]=set[j];set[j]=temp;
}
}
template <class T>
int Array<T>::seek(T key)
{
int i;
for(i=0;i<n;i++)
if(set==key)
return i;
return -1;
}
template<class T>
T Array<T>::sum()
{
T s=0;int i;
for(i=0;i<n;i++)
s+=set;
return s;
}
template<class T>
void Array<T>::disp()
{
int i;
for(i=0;i<n;i++)
cout<<set<< ;
cout<<endl;
}
void main()
{
int a[]={6,3,8,1,9,4,7,5,2};
double b[]={23,61,15,84,67,38};
Array<int>arr1(a,9);
Array<double>arr2(b,6);
cout<< arr1:<<endl;
cout<< 原序列:; arr1disp();
cout<< 8在arr1中的位置:<<arr1seek(8)<<endl;
arr1sort();
cout<< 排序后:; arr1disp();
cout<<arr2:<<endl;
cout<< 原序列:; arr2disp();
cout<< 84在arr2中的位置:<<arr2seek(84)<<endl;
arr2sort();
cout<< 排序后:; arr2disp();
}
main()
{
int i,j;
int a=0;/定义整形的数据i,j,a,并且定义a的初值为0/
for(i=1;i<=4;i++)/开始循环，条件是：从i=1开始到i=4结束（包括i=4），每次循环i自加1。/
{
a=5-i;/将5-i给a赋值，每次关于i的循环都会被重新赋值的/
for(j=1;j<=i;j++)/在上循环条件下，进行关于j的循环（例如：当i循环到2时，j进行从1到2的循环共两次，而当i=4时，j进行从1到4的4次循环。）/
{
printf("%d ",a);/打印a以及一个空格/
a=a+5-j;/打印结束后，用a+5-j给a赋值；然后在符合j循环的条件下，继续j循环，否则直接进入i的大循环/
}
printf("\n");/i的每次循环都要打印一个回车，即换行/
}/当循环中i=5时判断出不合条件，不在进入循环，程序结束/
}
#include<stdioh>
main()
{
int a,b,c,d,i,sum=0;
for(a=1;a<=26;a++)
for(d=1;d<=26;d++)
{ /等差数列前四项之和/
b = a + a + d + a + 2 d + a + 3 d;
/b = 4 a + 6 d /
if(b!=26)
continue;
else
{ /等差数列前四项之积/
c = a (a + d) (a + 2 d) (a + 3 d);
if(c!=880)
continue;
else
for(i=0;i<6;i++)
{
printf("%d,",a+id);
sum=sum+(a+id);
}
}
}
printf("\n数列的前6项的和：%d\n",sum);
}
! “非”运算。 非真为假，非假为真。
----------
^ “异或”运算， 按位运算符
参与运算的两个值，如果两个相应位相同，则结果为0，否则为1。即：0^0=0， 1^0=1， 0^1=1， 1^1=0
------
A ^! B -- 先计算 （非B） ，再计算 A 异或 （非B）
1、java是纯面向对象的语言（main都是写到类里的），所以没有原生的模板功能。
2、使用“模板模式”可以实现类似的效果，这也是java里最常用的模式之一。
以下是一篇教程：
模板方法模式的结构
模板方法模式是所有模式中最为常见的几个模式之一，是基于继承的代码复用的基本技术。
模板方法模式需要开发抽象类和具体子类的设计师之间的协作。一个设计师负责给出一个算法的轮廓和骨架，另一些设计师则负责给出这个算法的各个逻辑步骤。代表这些具体逻辑步骤的方法称做基本方法(primitive method)；而将这些基本方法汇总起来的方法叫做模板方法(template method)，这个设计模式的名字就是从此而来。
模板方法所代表的行为称为顶级行为，其逻辑称为顶级逻辑。模板方法模式的静态结构图如下所示：
这里涉及到两个角色：
抽象模板(Abstract Template)角色有如下责任：
■定义了一个或多个抽象 *** 作，以便让子类实现。这些抽象 *** 作叫做基本 *** 作，它们是一个顶级逻辑的组成步骤。
■定义并实现了一个模板方法。这个模板方法一般是一个具体方法，它给出了一个顶级逻辑的骨架，而逻辑的组成步骤在相应的抽象 *** 作中，推迟到子类实现。顶级逻辑也有可能调用一些具体方法。
具体模板(Concrete Template)角色又如下责任：
■实现父类所定义的一个或多个抽象方法，它们是一个顶级逻辑的组成步骤。
■每一个抽象模板角色都可以有任意多个具体模板角色与之对应，而每一个具体模板角色都可以给出这些抽象方法（也就是顶级逻辑的组成步骤）的不同实现，从而使得顶级逻辑的实现各不相同。
源代码
抽象模板角色类，abstractMethod()、hookMethod()等基本方法是顶级逻辑的组成步骤，这个顶级逻辑由templateMethod()方法代表。
public abstract class AbstractTemplate {/
模板方法
/
public void templateMethod(){
//调用基本方法
abstractMethod();
hookMethod();
concreteMethod();
}
/
基本方法的声明（由子类实现）
/
protected abstract void abstractMethod();
/
基本方法(空方法)
/
protected void hookMethod(){}
/
基本方法（已经实现）
/
private final void concreteMethod(){
//业务相关的代码
}
}
具体模板角色类，实现了父类所声明的基本方法，abstractMethod()方法所代表的就是强制子类实现的剩余逻辑，而hookMethod()方法是可选择实现的逻辑，不是必须实现的。
public class ConcreteTemplate extends AbstractTemplate{//基本方法的实现
@Override
public void abstractMethod() {
//业务相关的代码
}
//重写父类的方法
@Override
public void hookMethod() {
//业务相关的代码
}
}
模板模式的关键是：子类可以置换掉父类的可变部分，但是子类却不可以改变模板方法所代表的顶级逻辑。
每当定义一个新的子类时，不要按照控制流程的思路去想，而应当按照“责任”的思路去想。换言之，应当考虑哪些 *** 作是必须置换掉的，哪些 *** 作是可以置换掉的，以及哪些 *** 作是不可以置换掉的。使用模板模式可以使这些责任变得清晰。
#include <stdioh>
#include<stringh>
int main(void) {
char echo[100] = {0};
// 你的代码
while(1)//无限循环
{
gets(echo);
if(strcmp(echo,"quit")==0)//循环终止的条件
break;
printf("%s\n",echo);
}
return 0;
}
以上就是关于C ++编写一个使用类模板对数组进行排序、查找和求元素和的程序。全部的内容，包括:C ++编写一个使用类模板对数组进行排序、查找和求元素和的程序。、用C语言编写程序的格式和方法、C语言求等差数列等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）