// algo1-2.cpp 计算1-1/x+1/x*x…的更快捷的算法
#include<stdio.h>
#include<sys/timeb.h>
void main()
{
  timeb t1,t2;
  long t;
  double x,sum1=1,sum=1;
  int i,n;
  printf("请输入x n: ");
  scanf("%lf%d",&x,&n);
  ftime(&t1); // 求得当前时间
  for(i=1;i<=n;i++)
  {
  sum1*=-1.0/x;
  sum+=sum1;
  }
  ftime(&t2); // 求得当前时间
  t=(t2.time-t1.time)*1000+(t2.millitm-t1.millitm); // 计算时间差
  printf("sum=%lf 用时%ld毫秒\n",sum,t);
}

// bo1-1.cpp 抽象数据类型Triplet和ElemType(由c1-1.h定义)的基本操作(8个)
Status InitTriplet(Triplet &T,ElemType v1,ElemType v2,ElemType v3)
{ // 操作结果:构造三元组T,依次置T的三个元素的初值为v1,v2和v3
  if(!(T=(ElemType *)malloc(3*sizeof(ElemType))))
  exit(OVERFLOW);
  T[0]=v1,T[1]=v2,T[2]=v3;
  return OK;
}

Status DestroyTriplet(Triplet &T)
{ // 操作结果：三元组T被销毁
  free(T);
  T=NULL;
  return OK;
}

Status Get(Triplet T,int i, ElemType &e)
{ // 初始条件：三元组T已存在，1≤i≤3。操作结果：用e返回T的第i元的值
  if(i<1||i>3)
  return ERROR;
  e=T[i-1];
  return OK;
}

Status Put(Triplet T,int i,ElemType e)
{ // 初始条件：三元组T已存在，1≤i≤3。操作结果：改变T的第i元的值为e
  if(i<1||i>3)
  return ERROR;
  T[i-1]=e;
  return OK;
}

Status IsAscending(Triplet T)
{ // 初始条件：三元组T已存在。操作结果：如果T的三个元素按升序排列，返回1，否则返回0
  return(T[0]<=T[1]&&T[1]<=T[2]);
}

Status IsDescending(Triplet T)
{ // 初始条件：三元组T已存在。操作结果：如果T的三个元素按降序排列，返回1，否则返回0
  return(T[0]>=T[1]&&T[1]>=T[2]);
}

Status Max(Triplet T,ElemType &e)
{ // 初始条件：三元组T已存在。操作结果：用e返回T的三个元素中的最大值
  e=T[0]>=T[1]?T[0]>=T[2]?T[0]:T[2]:T[1]>=T[2]?T[1]:T[2];
  return OK;
}

Status Min(Triplet T,ElemType &e)
{ // 初始条件：三元组T已存在。操作结果：用e返回T的三个元素中的最小值
  e=T[0]<=T[1]?T[0]<=T[2]?T[0]:T[2]:T[1]<=T[2]?T[1]:T[2];
  return OK;
}

// c1-1.h 采用动态分配的顺序存储结构
typedef ElemType *Triplet; // 由InitTriplet分配三个元素存储空间
// Triplet类型是ElemType类型的指针，存放ElemType类型的地址

// c1.h (程序名)
#include<string.h>
#include<ctype.h>
#include<malloc.h> // malloc()等
#include<limits.h> // INT_MAX等
#include<stdio.h> // EOF(=^Z或F6),NULL
#include<stdlib.h> // atoi()
#include<io.h> // eof()
#include<math.h> // floor(),ceil(),abs()
#include<process.h> // exit()
#include<iostream.h> // cout,cin
// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE

// f.cpp 变量的引用类型和非引用类型的区别
#include<stdio.h>
void fa(int a) // 在函数中改变a，将不会带回主调函数(主调函数中的a仍是原值)
{
  a=5;
  printf("在函数fa中：a=%d\n",a);
}

void fb(int &a) // 由于a为引用类型，在函数中改变a，其值将带回主调函数
{
  a=5;
  printf("在函数fb中：a=%d\n",a);
}

void main()
{
  int n=1;
  printf("在主程中，调用函数fa之前：n=%d\n",n);
  fa(n);
  printf("在主程中，调用函数fa之后,调用函数fb之前：n=%d\n",n);
  fb(n);
  printf("在主程中，调用函数fb之后：n=%d\n",n);
}

// main1-1.cpp 检验基本操作bo1-1.cpp的主函数
#include"c1.h" // 要将程序中所有#include命令所包含的文件拷贝到当前目录下
// 以下2行可根据需要选用一个（且只能选用一个），而不需改变基本操作bo1-1.cpp
typedef int ElemType; // 定义抽象数据类型ElemType在本程序中为整型
//typedef double ElemType; // 定义抽象数据类型ElemType在本程序中为双精度型
#include"c1-1.h" // 在此命令之前要定义ElemType的类型
#include"bo1-1.cpp" // 在此命令之前要包括c1-1.h文件（因为其中定义了Triplet）
void main()
{
  Triplet T;
  ElemType m;
  Status i;
  i=InitTriplet(T,5,7,9);
//i=InitTriplet(T,5.0,7.1,9.3); // 当ElemType为双精度型时,可取代上句
  printf("调用初始化函数后，i=%d(1:成功) T的三个值为：",i);
  cout<<T[0]<<' '<<T[1]<<' '<<T[2]<<endl;
  // 为避免ElemType的类型变化的影响，用cout取代printf()。注意结尾要加endl
  i=Get(T,2,m);
  if(i==OK)
  cout<<"T的第2个值为："<<m<<endl;
  i=Put(T,2,6);
  if(i==OK)
  cout<<"将T的第2个值改为6后，T的三个值为："<<T[0]<<' '<<T[1]<<' '<<T[2]<<endl;
  i=IsAscending(T); // 此类函数实参与ElemType的类型无关,当ElemType的类型变化时,实参不需改变
  printf("调用测试升序的函数后，i=%d(0:否 1:是)\n",i);
  i=IsDescending(T);
  printf("调用测试降序的函数后，i=%d(0:否 1:是)\n",i);
  if((i=Max(T,m))==OK) // 先赋值再比较
  cout<<"T中的最大值为："<<m<<endl;
  if((i=Min(T,m))==OK)
  cout<<"T中的最小值为："<<m<<endl;
  DestroyTriplet(T); // 函数也可以不带回返回值
  cout<<"销毁T后，T="<<T<<"(NULL)"<<endl;
}