第一题：doit()函数即可完成前移工作和输出工作
创新互联建站是一家集网站建设,武胜企业网站建设,武胜品牌网站建设,网站定制,武胜网站建设报价,网络营销,网络优化,武胜网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。
#include stdio.h
const L=10;
void doit(int *a, int pos)
{
int i;
if(pos0 || posL-1)
{
printf("a[%d]不存在!\n", pos);
return;
}
else for (i=pos; iL-1; i++)
a[i] = a[i+1];
for(i=0; iL-1; i++) printf("%d ", a[i]);
printf("\n");
}
void main()
{
int a[L] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
int n, i;
printf("数组原来的数据: \n");
for(i=0; iL; i++) printf("%d ", a[i]);
printf("\n");
printf("从a[n]开始向前移位，其中n=");
scanf("%d", n);
doit(a, n-1);
}
第二题： doit()函数即可完成将数组a中所有质数放入数组b中的任务，最后返回值为b中质数的个数
#include stdio.h
#include malloc.h
const N=26;
int doit(int *a, int *b)
{
int i, j=-1;
for (i=0; iN; i++)
if (a[i]%2!=0)
{
j++;
b[j] = a[i];
}
return(j+1);
}
void main()
{
int a[N]={0,2,3,4,5,
7,8,11,23,
24,22,211,
45,8,7,14,
16,21,101,
-2,-1,0,9,
100,101,1};
int b[N];
int i, tot;
tot = doit(a, b);
for (i=0; itot; i++)
printf("%d ",b[i]);
printf("\n");
}
太简单，懒得答，抄来的：
Bubble Sort(冒泡法)
最简单的排序方法是冒泡排序方法。这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即“轻”的元素在下面，就交换它们的位置。显然，处理一遍之后，“最轻”的元素就浮到了最高位置；处理二遍之后，“次轻”的元素就浮到了次高位置。在作第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。这个算法可实现如下。
Bubble Sort程序：
STL C++程序：(VC++6.0通过)
#include "stdafx.h"
#include "iostream.h"
templateclass T
class doit{
private:
int x,y;
T temp;
public:
doit(T* in,int count)
{
for(y=0;ycount-1;y++)
{
for(x=1;xcount-y;x++)
{
if((*(in+x))(*(in+x-1)))
{
temp=(*(in+x-1));
(*(in+x-1))=(*(in+x));
(*(in+x))=temp;
}
}
}
}
};
int main()
{
double a[4]={1.1,1.3,1.9,2.2};
doitdouble d(a,4);
for(int i=0;i4;i++)
{
couta[i]endl;
}
return 0;
}
C语言程序：(TC 2.0通过)
void doit(float* in,int count)
{
int x;
int y;
float temp;
for(y=0;ycount-1;y++)
{
for(x=1;xcount-y;x++)
{
if((*(in+x))(*(in+x-1)))
{
temp=(*(in+x-1));
(*(in+x-1))=(*(in+x));
(*(in+x))=temp;
}
}
}
}
int doit(int x, int y,int (*fun)(int ,int ))
{
......................
a=(*fun)(x,y)；
..................调用一个函数；
return(a);
}
int max(int x,int y)
{
............
}
int min...................
...........连续四个函数；
void mian()
{
.................
将tingcase=max ,min, .,............其中一个；就可以实现你要的功能了;
result=doit(x,y,tingcase);
}
主干部分就是这样了，函数的实现部分。应该知道了吧，望采纳哦。嘻嘻
简单来说：宏定义又称为宏代换、宏替换，简称“宏”。宏替换是C/C++的预处理中的一部分,在C++标准中有4条规则来定义替换。
规则1：实参替换。
本条规则描述带参数的宏的替换过程。
对于宏定义中的形参,在替换列表中,如果不是作为#或##的操作数,那么将对应实参完全
展开(相当于对实参进行求值),然后将替换列表中的形参替换掉.如果是#或##的操作数，
那么不进行替换。
规则2：多次扫描。
在所有的形参替换为实参后,对结果进行再次扫描,如果发现还有可替换的宏,则进行替换，
否则中止。
规则3：递归替换抑制。
如果在替换列表中发现当前正在展开的宏的名字，那么这里不进行替换.更进一步,在嵌套
的替换过程中发现已经替换过的宏的名字,则不进行替换。
规则4：递归预处理抑制。
如果替换后的结果形成预处理指令，则不执行这条预处理指令。
看几个C++标准中的例子：
#define x 3
#define f(a) f(x * (a))
#undef x
#define x 2
#define g f
#define z z[0]
#define h g(~
#define m(a) a(w)
#define w 0,1
#define t(a) a
f(y+1) + f(f(z)) % t(t(g)(0) + t)(1)；
g(x+(3,4)-w) | h 5) m(f)^m(m)；
其结果分别是
f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1)；
f(2 * (2+(3,4)-0,1)) | f(2 * ( ~ 5)) f(2 * (0,1))^m(0,1)；
对于第一个,主要在于t(t(g)(0) + t)(1)的展开。
容易计算出最外层的t的实参是f(2 * (0)) + t，而作为t的参数传入时其中的t是
正在被展开的宏,所以根据规则3,不对这个t进行处理,保持不变,得到f(2 * (0)) + t(1)。
对于第二个，h 5)被替换为g(~5)，应用规则2，被替换为f(2 * ( ~ 5))。
而m(m)首先被替换为m(w)，然后应用规则2再次进行替换，但是m已经是替换过的了，所以保持
不变,只对w进行替换。
#define str(s) # s
#define xstr(s) str(s)
#define debug(s, t) printf("x" # s "= %d, x" # t "= %s", \
x ## s, x ## t)
#define INCFILE(n) vers ## n /* from previous #include example */
#define glue(a, b) a ## b
#define xglue(a, b) glue(a, b)
#define HIGHLOW "hello"
#define LOW LOW ", world"
debug(1, 2);
fputs(str(strncmp("abc\0d", "abc", ’\4’) /* this goes away */
== 0) str(: @\n), s);
#include xstr(INCFILE(2).h)
glue(HIGH, LOW);
xglue(HIGH, LOW)
其结果分别是
printf("x" "1" "= %d, x" "2" "= %s", x1, x2);
fputs("strncmp(\"abc\\0d\", \"abc\", ’\\4’) = = 0" ": @\n", s);
#include "vers2.h"
"hello";
"hello" ", world"
关键是glue和xglue.
对于glue(HIGH, LOW)，首先有一个规则1的抑制,得到HIGHLOW;的结果,然后二次扫描,得到
"hello"；
对于xglue(HIGH, LOW)没有抑制效果,所以对参数求值,分别得到HIGH和LOW ", world",即
glue(HIGH, LOW ", world")。
然后进行连接操作得到HIGHLOW ", world",最后再扫描一次得到"hello" ", world"
如果考虑字符串的自然的连接,就可以得到"hello, world"了。
扩展资料
宏语言是一类编程语言，其全部或多数计算是由扩展宏完成的。宏语言并未在通用编程中广泛使用，但在文本处理程序中应用普遍。例如， C preprocessor C预处理器Internet Macros(iOpus) M4(如前所述，源于ATT，捆绑于Unix)
宏定义
c程序提供的预处理功能之一。包括带参数的宏定义和不带参数的宏定义。具体是指用一个指定的标志符来进行简单的字符串替换或者进行阐述替换。形式为：
#define标志符[（参数表）] 字符串
宏名
在上定义中的标志符被称为“宏名”。
宏展开
在c程序编译时将宏名替换成字符串的过程称为“宏展开”。
宏语言是一类编程语言，其全部或多数计算是由扩展宏完成的。宏语言并未在通用编程中广泛使用， 但在文本处理程序中应用普遍。例如，
C preprocessorC 预处理器
Internet Macros(iOpus)
M4(如前所述，源于ATT，捆绑于Unix)
参考资料来源：百度百科-宏
//此程序可计算四则混合运算，输入时直接输入数学表达式，如2+9*5/3-1.......
//应注意的是，若有除法则只能取整。
#includemath.h
#includestdio.h
#includestring.h
#includestdlib.h
#includealloc.h
#define N 30
char *qkh(char *p);
char *ccf(char *p);
char *jjf(char *p);
char *zkh(char *p);
void hy(char *temp,char *p,int n);
int i=0;
void main()
{
char *s2,*p1=NULL,*temp;s2=(char *)malloc(N);clrscr();
gets(s2);
for(;*(s2+i)!='\0';i++)
{
p1=zkh(s2);
if(p1!=NULL)
{
i=1;
while(*(p1+i)!=')')
i++;
temp=qkh(p1);
hy(temp,p1-1,i+2);
i=0;
}
else
{
s2=ccf(s2);
s2=jjf(s2);
}
}
printf("\nthe value is %s",s2); getch();
}
char *qkh(char *p)
{
char *p1;
*(p+i)='\0';
p1=(char *)malloc(strlen(p));
strcpy(p1,p);
p1=ccf(p1);
p=jjf(p1);
return p;
}
void hy(char *sum,char *s2,int n)
{
strcat (sum,s2+n);
strcpy(s2,sum);
}
char *ccf(char *s2)
{
int i;
char *a,*b,*sum,*temp,*a1,*b1;
for (i=1;*(s2+i)!='*'*(s2+i)!='/'*(s2+i);i++);
if(*(s2+i)=='\0')
return s2;
else
{
char f1=*(s2+i),f2;
int x=1;
for (;(i-x)(*(s2+i-x)!='+'*(s2+i-x)!='-');x++);
*(s2+i)='\0';
if(i-x) a1=s2+i-x+1;
else
a1=s2+i-x;
a=(char *)malloc(strlen(a1));
strcpy(a,a1);
*(s2+i)=f1;
for(x=2;*(s2+i+x)!='+'*(s2+i+x)!='-'*(s2+i+x)!='*'*(s2+i+x)!='/'*(s2+i+x);x++);
f2=*(s2+i+x);
*(s2+i+x)='\0';
b1=s2+i+1;
b=(char *)malloc(strlen(b1));
strcpy(b,b1);
*(s2+i+x)=f2;
{
int a1,b1;
sum=(char *)malloc(strlen(a)+strlen(b));
a1=atoi(a);b1=atoi(b);
if(f1=='*')
itoa(a1*b1,sum,10);
else
itoa(a1/b1,sum,10);
}
{
int m=i;while(*(s2+m)!='+'*(s2+m)!='-'m)m--;
if(m)hy(sum,s2+m+1,i-1-m+x);
else
hy(sum,s2,i+x);}
for(i=1;(*(s2+i)!='*'*(s2+i)!='/')*(s2+i);i++);
if(*(s2+i)=='\0')
return s2;
else
ccf(s2);
}
}
char *zkh(char *p)
{
int i;
for (i=0;*(p+i)!=')'*(p+i);i++);
if(!(*(p+i))) return NULL;
else
{
int a;
for (a=i-1;*(p+a)!='(';a--);
return p+a+1;
}
}
char *jjf(char *s2)
{
int i;
char *a,*b,*sum,*temp,*a1,*b1;
for (i=1;*(s2+i)!='+'*(s2+i)!='-'*(s2+i);i++);
if(*(s2+i)=='\0')
return s2;
else
{
char f1=*(s2+i),f2;
int x=1;
*(s2+i)='\0';
a1=s2;
a=(char *)malloc(strlen(a1));
strcpy(a,a1);
*(s2+i)=f1;
for(x=2;*(s2+i+x)!='+'*(s2+i+x)!='-'*(s2+i+x);x++);
f2=*(s2+i+x);
*(s2+i+x)='\0';
b1=s2+i+1;
b=(char *)malloc(strlen(b1));
strcpy(b,b1);
*(s2+i+x)=f2;
{
int a1,b1,m;
sum=(char *)malloc(strlen(a)+strlen(b));
a1=atoi(a); b1=atoi(b);
if(f1=='+')
{m=a1+b1; itoa(m,sum,10); }
else
{m=a1-b1; itoa(m,sum,10);}
}
hy(sum,s2,i+x);
for(i=1;(*(s2+i)!='+'*(s2+i)!='-')*(s2+i);i++);
if(*(s2+i)=='\0')
return s2;
else
jjf(s2);
}
}
转了我同学的 貌似还要改下才能符合要求
宏是一种预处理指令，它提供了一种机制，可以用来替换源代码中的字符串。
1、条件编译：
C语言中，预处理过程读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行相应的转换，预处理过程还会删除程序中的注释和多余的空白符号。
预处理指令是以#开头的代码行，#必须是该行除了空白字符外的第一个字符。#后是指令关键字，在#和指令关键字之间允许存在若干空白字符。
使用宏进行条件编译的用法与使用宏防止多重引用类似。示例如下：
使用条件编译，方便程序员在调试程序的过程中，执行一些在程序发布后并不需要执行的指令。只要在需要调试的代码前加上_DEBUG的定义，就可以在调试程序的过程中输出调试信息。
这样方便查看程序在运行过程中有没有出现错误，定位错误出现的地方。而在程序发布之前，取消_DEBUG的定义就可以不再执行调试代码。
2、宏函数：
函数的调用是需要一定的时间和空间代价的。因为系统在调用函数时，需要保留"现场"，即将程序要执行的指令的下一条指令的位置压入栈，然后转入调用函数去执行，调用完函数后再返回主调函数，恢复"现场"，返回到栈里保存的的下一条指令的位置继续执行。
所以函数的调用需要额外的时间和空间代价。
而宏函数则不存在上述问题，宏函数在预编译时，同函数定义的代码来替换函数名，将函数代码段嵌入到当前程序，不会产生函数调用。
所以会省去普通函数保留现场恢复现场的时间，但因为要将定义的函数体嵌入到当前程序，所以不可避免的会占用额外的存储空间。
在频繁调用同一个宏的时候，该现象尤其明显。宏函数的示例定义如下：
#define MAX(a,b) ((a)(b)?(b):(a))
宏函数的优点在于避免函数调用，提高程序效率。
同时需要注意的是inline标识符。inline也将函数定义为内联的。但是使用内联函数需要注意的是：函数体必须十分简单，不能含有循环、条件、选择等复杂结构，否则就不能作为内联函数了。
事实上，有时候即便你没有将函数指定为内联函数，编译器也会将一些简单的函数作为内联函数处理，而对于一些复杂的函数，即使声明为内联函数，编译器也不会理会的。
inline函数的瓶颈就在于此，使用inline标识符将函数声明为内联的，但这只是一种提示，到底编译器有没有优化还依赖于编译器的实现，而使用宏函数则完全由代码本身控制。
但在使用宏函数的时候，需要明确的是宏函数只是简单的替换，需要注意括号的使用。
扩展资料：
宏的更多规则特性：
（1）宏名一般用大写。
（2）使用宏可提高程序的通用性和易读性，减少不一致性，减少输入错误和便于修改。例如：数组大小常用宏定义。
（3）预处理是在编译之前的处理，而编译工作的任务之一就是语法检查，预处理不做语法检查。
（4）宏定义末尾不加分号。
（5）宏定义写在函数的花括号外边，作用域为其后的程序，通常在文件的最开头。
（6）可以用#undef命令终止宏定义的作用域。
（7）宏定义不可以嵌套。
（8）字符串" "中永远不包含宏。
（9）宏定义不分配内存，变量定义分配内存。
（10）宏定义不存在类型问题，它的参数也是无类型的。
参考资料：
百度百科--宏定义
重庆分公司
重庆分公司
