c语言数组函数,c语言中能不能定义函数数组

c语言数组函数,c语言中能不能定义函数数组详细介绍

本文目录一览： c语言中能不能定义函数数组

1、首先，我们编写头文件以及main函数主框架。
2、然后我们编写如图语句，int可更改为任意其他类型。
3、接下来我们可以for语句给他赋值。
4、为了方便测试，我们可以将其输出。
5、然后我们点击编译运行按钮。
6、这个时候我们便可以看到如下图效果。
函数不可以定义为数组，可以用函数指针来操作。
1.函数指针的数组定义方法：返回值类型( * 指针变量名[Number]) (形参列表)。例如：double add(double a,double b){};double sub(double a,double b){};double mul(double a,double b){};double div1(double a,double b){};double (*oper_func[])(double, double) = {add,sub,mul,div1};//函数指针的数组定义2.函数指针是指向函数的指针变量。 因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是大体一致的。函数指针有两个用途：调用函数和做函数的参数。3.函数指针的声明方法为：返回值类型( * 指针变量名) (形参列表);“返回值类型”说明函数的返回类型，“( * 指针变量名)”中的括号不能省，括号改变了运算符的优先级。若省略整体则成为一个函数说明，说明了一个返回的数据类型是指针的函数，后面的“形参列表”表示指针变量指向的函数所带的参数列表。例如：int func(int x); /* 声明一个函数 */int (*f) (int x); /* 声明一个函数指针 */f = func; /* 将func函数的首地址赋给指针f */或者使用下面的方法将函数地址赋给函数指针：f = &func;赋值时函数func不带括号，也不带参数，由于func代表函数的首地址，因此经过赋值以后，指针f就指向函数func(x)的代码的首地址。例子：
#include

int max(int x,int y){return (x>y? x:y);}int main(){ int (*ptr)(int, int); int a, b, c; ptr = max; scanf("%d%d", &a, &b); c = (*ptr)(a,b); printf("a=%d, b=%d, max=%d", a, b, c); return 0;}

可以的兄弟，函数数组就是把函数的地址存入数组，可以定义一个指针数组传入函数名。但是我建议要存储一系列函数的地址的话最好定义一个结构体把函数地址传入，把结构体加入链表中，操作系统中这样做很常见。

给你个例子

fun function[4]={print_on_a,print_on_b,print_on_c,print_on_d};

看到没数组中都是函数名，函数名实际上就是函数的地址，就和数组名是数组地址一样。

具体代码如下：

#include

typedef void (*fun)(void); //这个是函数指针

void print_on_a()

{

printf("a\n");

}

void print_on_b()

{

printf("b\n");

}

void print_on_c()

{

printf("c\n");

}

void print_on_d()

{

printf("d\n");

}

void main()

{

fun function[4]={print_on_a,print_on_b,print_on_c,print_on_d};

(*function[0])();

}

#include

#include

typedef int (*PF_CALC) (int a, int b);

int func1(int a, int b)

{

return a+b+10;

}

int func2(int a, int b)

{

return a+b+20;

}

int func3(int a, int b)

{

return a+b+30;

}

int func4(int a, int b)

{

return a+b+40;

}

int func5(int a, int b)

{

return a+b+50;

}

void main()

{

PF_CALC pFuncList[5] = {func1, func2, func3, func4, func5};

for (long k=0; k<5; k++)

{

printf("Test Func %d (2, 4): %d\n",

k, pFuncList[k](2,4));

}

}

但是函数指针有时有移植的问题，所以我会选择以下代码，容易理解和维护：

int func_all(int type, int a, int b)

{

switch(type)

{

case 0: return func1(a,b);

case 1: return func2(a,b);

case 2: return func3(a,b);

case 3: return func4(a,b);

case 4: return func5(a,b);

}

return 0;

}

void main()

{

// PF_CALC pFuncList[5] = {func1, func2, func3, func4, func5};

for (long k=0; k<5; k++)

{

printf("Test Func %d (2, 4): %d\n",

k, func_all(k,2,4));

}

}

#include

int fun0(int x,int y)

{

return (x+y);

}

int fun1(int x,int y)

{

return (x-y);

}

int fun2(int x,int y)

{

return (x*y);

}

int fun3(int x,int y)

{

return (x/y);

}

void main()

{

int a=10,b=5,i,c;

//在c环境下int (*p[4])()={fun0,fun1,fun2,fun3};能通过,c++就不行

int (*p[4])(int,int)={fun0,fun1,fun2,fun3};//定义指向函数的指针数组p

for(i=0;i<4;i++)

{

c=p[i](a,b);//执行不同操作

printf("fun(%d):%d\n",i,c);

}

}

函数不可以定义为数组，可以用函数指针来操作。

1.函数指针的数组定义方法：返回值类型( * 指针变量名[Number]) (形参列表)。例如：

double add(double a,double b){}

double sub(double a,double b){}

double mul(double a,double b){}

double div1(double a,double b){}

double (*oper_func[])(double, double) = {add,sub,mul,div1};//函数指针的数组定义。

2.函数指针是指向函数的指针变量。 因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。

C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数。

扩展资料：

指针函数和函数指针的区别：

这两个概念都是简称，指针函数是指返回值是指针的函数，即本质是一个函数。我们知道函数都有返回类型（如果不返回值，则为无值型），只不过指针函数返回类型是某一类型的指针。其定义格式如下所示：返回类型标识符*函数名称。

返回类型可以是任何基本类型和复合类型。返回指针的函数的用途十分广泛。事实上，每一个函数，即使它不带有返回某种类型的指针，它本身都有一个入口地址，该地址相当于一个指针。比如函数返回一个整型值，实际上也相当于返回一个指针变量的值，不过这时的变量是函数本身而已，而整个函数相当于一个“变量”。

参考资料：百度百科 - 函数指针

在C语言中怎么将子函数中的数组和函数调用出来？

首先这样的作法是没有意义的，因为当函数返回之后，函数原始空间中的数组和变量是临时的，都会被自动清除和释放。如果需要通过函数将改变的结果传回，可以使用指针。
void shuru(int* p,int a[]){
*p = 123;
int b[10]={1,2,3,4,5,4,6,7};
for (int i=0;i<9;i++)
a[i]=b[i]
}
void main(){
int b, a[10] ;
shuru(&b,a);
printf("%d",b);
for(int i=0;i<10;i++){
printf("%d",a[i]);
}
}
其实超级简单，我是花了一整个小时才做出来的这种，
#include

#include

#include

void fzz(int c[80][80],int len){//这里面是子函数内容}int main (void){ int a[80][80];printf("请输入方阵的阶数(小于81)：");scanf("%d",&js);for (i=0;i
<js;i++){ for (j="0;j<js;j++){printf("请输入第%d行第%d列元素：",i+1,j+1);scanf("%d",&a[i][j]);" } }fzz(a,js); 这个地方调用两个，一个是数字首地址a，另外一个就是重要的阶数js，或者是几行几列
#include

#include

#include

#include

using namespace std;

//法一：子函数内将数组指针复制给形参指针，正如楼上的思路

//法二：return返回指针（需要用C++）

int* shuzu()

{

int i;

int a[10] = {1,2,3};

int *pa;

pa=a;

srand((int)time(0));

for(i=0;i<10;i++)

{

a[i]=rand()%10;

printf("%d",*(pa+i));

}

printf("\n\n");

return pa;

}

int main()

{

int *pb;

int i;

pb = shuzu();

for(i=0;i<10;i++)

{

printf("%d",*(pb+i));

}

return 0;

}

来传送子函数中的数组有多种方法——可以通过函数返回值返回地址传递数组；也可以通过函数输入参数来传递数组；还可以通过全局变量来传递数组。

子函数本身可以直接在作用域中进行调用。

1、通过函数返回值返回地址传递数组。

声明函数时需要声明函数返回值类型为对应数组的地址，此时可以返回数组的地址，结合数组元素的地址关系可以传递整个数组，同时可以根据数组的特性传递多个参数。

2、通过输入参数传递数组。

声明函数时提供空输入参数，调用函数时提供目标数组，即可以通过该数组调用子函数中的数组，该方法也可以用于传递多个参数。

3、通过全局变量来传递数组。

声明全局变量用于存储子函数中的数组，此时可以在全局变量作用域中读取调用子函数的数组。

注意：子函数是C语言模块化编程思想的核心，其方法是通过输入接口和输出接口实现对黑盒的调用，故对其内部数据的输入和调用也需要通过输入接口、输出接口和程序的公共区域实现。

c语言数组长度函数

比如说是int类型的数组， 数组为 int arr[ ]={3,5,6,5,......}
计算数组中元素个数的方法为，求出总数组大小，除以每个元素的大小，就得出元素的个数。
个数= sizeof(arr) / sizeof(int)
注意： 这里的arr单独出现的话代表的是整个数组，不是首地址。
若想让它代表首地址， 用arr+0即可， 比如求首地址的大小， 其实就是指针的大小4，
sizeof(arr+0) 结果肯定是4. 不信你自己cout输出测试下。
同理，无论什么类型的数组，都用这种方法
sizeof(首指针) / sizeof(类型)

c语言函数怎么调用数组部分

一、数组可定义为全局变量，函数直接调用。
二、数组可定义为局部变量，再通过参数传递到函数中调用（实参传数组名，表示数组首地址，也可通过指针或数组名+数字来传递数组局部地址）。
三、main函数想要调用函数返回的数组，可用static定义静态变量或malloc定义动态数组(字符串常量也可返回使用，但局部变量，在函数调用结束会被释放，不能作为返回地址使用)。
下面是演示代码：
#include

#include

#include

char str1[]="我是全局变量数组";

char *fun0(char str2[]);

char *fun1();

char *fun2();

int main()

{

char *str3=NULL,*str4=NULL,*str5=NULL;

char str2[]="我是main函数的局部数组变量";

str3=fun0(str2);

printf("str3:%s,fun函数调用结束，我的地址依然可以使用\n",str3);

str4=fun1();

printf("str4:%s,fun函数调用结束，我的地址依然可以使用\n",str4);

str5=fun2();

printf("str5:%s,fun函数调用结束，函数结束不会自动释放\n",str5);

free(str5);

return 0;

}

char *fun0(char s[])

{

static char str3[]="我是fun函数申明的静态数组变量";

printf("str1:%s,fun函数可以直接调用\n",str1);

printf("str2:%s,fun函数通过参数将我的地址传进来\n",s);

return str3;

}

char *fun1()

{

char *str4="我是fun1函数的字符串常量";

return str4;

}

char *fun2()

{

int len;

char sTemp[]="这是一个临时数组，之后用于给mallc申请的地址传值，传递内容为：（我是fun函数通过mallic申请的数组）";

char *str5=NULL;

len=strlen(sTemp+63);

str5=(char *)malloc(sizeof(char)*len+1);

if(!str5)return NULL;

strcpy(str5,sTemp+63);

str5[len-2]=0;

return str5;

}

C语言编写函数求数组中最小值

int min=array[0];for(int i=1;i

a[i]) { min=a[i]; index=i; }}return min;

int findMin(int szIn[], int size){ int tmpMin = szIn[0]; for(int i = 0; i < size; ++i) { if(tmpMin <= szIn[i]） { tmpMin = szIn[i]; } } return tmpMin;}

#include

#define MAX_SIZE 100 //我随便写的，需要自己改

void get_array(int *array,int size)

{

printf("请输入：\n");

for(int i=0;i
<size;i++)
scanf("%d",&array[i]);

}

int min_index(int *array,int size)

{

int min=array[0];

for(int i=1;i
<size;i++)
if(array[i]
<min)
min=array[i];

return min;

}

int main()

{

int array[MAX_SIZE], size, index;

scanf("%d", &size);

get_array(array, size);//上面已经给出函数

index = min_index(array, size);//在main函数前不用声明

printf("minimum number is %d, whose position is %d.\n", array[index], index);

return 0;

}

#include"stdio.h"

#define MAX_SIZE 100

void get_array(int a[],int size)

{int i;

for(i=0;i
<size;i++)
scanf("%d",&a[i]);

}

int min_index(int a[],int size)

{int i,min=0;

for(i=1;i
<size;i++)
if(a[i]
<a[min])min=i;
return min;

}

int main()

{

int array[MAX_SIZE], size, index;

scanf("%d", &size);

get_array(array, size);

index = min_index(array, size);

printf("minimum number is %d, whose position is %d.", array[index], index);

system("pause");

return 0;

}

可以参考下面的代码：

int findMin(int szIn[], int size)

{

int tmpMin = szIn[0];

for(int i = 0; i < size; ++i)

{

if(tmpMin <= szIn[i]）

{

tmpMin = szIn[i];

}

}

return tmpMin;

}

扩展资料：

C语言isupper()函数：判断一个字符是否是大写字母

C语言isspace()函数：判断一个字符是否是空白符

C语言isprint()函数：判断一个字符是否是可打印字符

C语言islower()函数：判断一个字符是否是小写字母

C语言ldexp()函数：返回x乘以2的exponent次方（次幂）的值

int isdigit(int ch) 若ch是数字('0'-'9')返回非0值,否则返回0

参考资料来源：百度百科-c语言

参考资料来源：百度百科-C语言函数
</a[min])min=i;
</size;i++)
</size;i++)
</min)
</size;i++)
</size;i++)

c语言定义一个用于输入整数数组元素的函数？

```c
#include

void input_array(int *arr, int n) {

int i;

printf("请输入 %d 个整数：

", n);

for (i = 0; i < n; i++) {

scanf("%d", &arr[i]);

}

}

```

以上是一个简单的函数定义，用于输入一个整数数组元素。其中，参数 `arr` 是指针类型，指向要输入的数组；参数 `n` 是数组的长度。函数内部使用 `for` 循环遍历数组，依次从标准输入中读取每个元素的值，并将其存入数组中。最后，函数返回时，输入的整数数组已经保存在指针变量 `arr` 所指向的位置上。

要定义一个用于输入整数数组元素的函数，您可以使用以下C语言代码：

在上述代码中，我们定义了一个名为input_array的函数，该函数接受两个参数：一个整数数组arr和一个整数n，表示数组的长度。函数使用for循环迭代数组中的每个元素，并使用scanf函数从用户输入中读取一个整数，并将其存储到当前元素中。

在main函数中，我们声明一个长度为10的整数数组arr，并使用input_array函数输入数组元素。您可以将数组长度和数组变量名更改为您需要的值。

请注意，上述代码中的输入方法是简单的示例代码，并且不具有健壮性。在实际编程中，您需要考虑各种输入情况，例如输入值不是整数等，以避免潜在的错误。

C语言中自定义的函数中有数组，应该如何运用该函数

方法
有2
将该数组定义为全局变量，即：
int
g_arr;
void
fun()
{...}
void
main()
{...}
2.将该数组作为函数参数传递到自定义函数里，即：
void
fun(int
arr[])
{...}
void
main()
{
int
arr[10];
fun(arr);
}

C语言数组的输出函数

#include
"stdio.h"
void
input(int
a[10])
//给一维数组输入数据
{
int
i;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
}
void
output(int
a[10])
//输出一维数组输入数据
{
int
i;
for(i=0;i<10;i++)
printf("%d
",a[i]);
}
int
main()
{
int
b[10];
input(b);
//调用input函数给数组b赋值
output(b);//调用output函数输出数组b中的值
}

c语言，字符数组函数

#include

#include

void fun(){

char str1[100],str2[100]; //两个字符串

int len1,len2; //字符串str1和str2的长度

scanf("%s",str1);

scanf("%s",str2);

len1=strlen(str1);

len2=strlen(str2);

if(!strcmp(str1,str2)){

printf("%s\n",str1);

return ;

}else{

if(len1
<len2){
strcat(str2,str1);

printf("%s\n",str2);

return;

}

else if(len1>=len2){

strcat(str1,str2);

printf("%s\n",str1);

return ;

}

}

}

int main(){

fun();

}

这样应该满足要求了

应该是练习strlen、strcat两个轮子函数的应用，如果不给用，只能造轮子了。

#include

#include

int main(){ char a[100],b[100]; int la, lb; scanf("%s%s",a,b); la = strlen(a); lb =strlen(b); if(la == la) printf("%s\n",a); else if(la < lb) { strcat(b,a); printf("%s\n", b); } else { strcat(a,b); printf("%s\n", a); } return 0;}

#include "stdio.h"#include "string.h"int main(int argc,char *argv[]){ char a[51],b[51]; printf("Input 2 strings...\n"); scanf("%25s%25s",a,b); fflush(stdin); if(!strcmp(a,b)) printf("%s\n",a); else if(strlen(a)>=strlen(b)) printf("%s\n",strcat(a,b)); else printf("%s\n",strcat(b,a)); return 0;}

//为什么没人写了呢：

char str1[250] = {0};

char str2[250] = {0};

while(1){

scanf("%s %s", str1, str2);

if(strcmp(str1, str2)){

if(strlen(str1)>strlen(str2)){

strcat(str1,str2);

printf("%s\n", str1);

}else{

strcat(str2, str1);

printf("%s\n", str2);

}

}else{

printf("%s\n",str1);

}

}

#include

/*比较两个字符串*//*src、dst相等 return 1*//*src比dst短 return -2*//*src比dst长 return 2*//*src、dst长度一致但不相等 return -1*/int stringCmp (char *src, char *dst) { if (strlen (src) < strlen (dst)) return -2; else if (strlen (src) > strlen (dst)) return 2; else { while (*src && *dst) { if (*src != *dst) return -1; src++; dst++; } return 1; }}/*合并两个字符串*/void mergeString(char* str1, char* str2, char* merge) { while (*merge++ = *str1++); /*复制str1并将指针移动到字符串的末尾的下一个位置*/ merge--; /*退到字符串的末尾*/ while (*merge++ = *str2++); /*从末尾(\0)的位置开始将str2拷贝进来*/ *merge = '\0';}int main(void) { char *str1_1="hel",*str1_2="lo", *merge1; char *str2_1="ness",*str2_2="happy", *merge2; char *str3_1="hi",*str3_2="hi", *merge3; char *str4_1="hello",*str4_2="world", *merge4; puts ("第1组字符串："); puts (str1_1); puts (str1_2); if (stringCmp (str1_1, str1_2) == 1) puts (str1_1); else if (stringCmp (str1_1, str1_2) == -2) { mergeString (str1_2, str1_1, merge1); puts (merge1); } else if (stringCmp (str1_1, str1_2) == 2 || stringCmp (str1_1, str1_2) == -1) { mergeString (str1_1, str1_2, merge1); puts (merge1); } putchar ('\n'); puts ("======================================================"); putchar ('\n'); puts ("第2组字符串："); puts (str2_1); puts (str2_2); if (stringCmp (str2_1, str2_2) == 1) puts (str2_1); else if (stringCmp (str2_1, str2_2) == -2) { mergeString (str2_2, str2_1, merge2); puts (merge2); } else if (stringCmp (str2_1, str2_2) == 2 || stringCmp (str2_1, str2_2) == -1) { mergeString (str2_1, str2_2, merge2); puts (merge2); } putchar ('\n'); puts ("======================================================"); putchar ('\n'); puts ("第3组字符串："); puts (str3_1); puts (str3_2); if (stringCmp (str3_1, str3_2) == 1) puts (str3_1); else if (stringCmp (str3_1, str3_2) == -2) { mergeString (str3_2, str3_1, merge3); puts (merge3); } else if (stringCmp (str3_1, str3_2) == 2 || stringCmp (str3_1, str3_2) == -1) { mergeString (str3_1, str3_2, merge3); puts (merge3); } putchar ('\n'); puts ("======================================================"); putchar ('\n'); puts ("第4组字符串："); puts (str4_1); puts (str4_2); if (stringCmp (str4_1, str4_2) == 1) puts (str4_1); else if (stringCmp (str4_1, str4_2) == -2) { mergeString (str4_2, str4_1, merge4); puts (merge4); } else if (stringCmp (str4_1, str4_2) == 2 || stringCmp (str4_1, str4_2) == -1) { mergeString (str4_1, str4_2, merge4); puts (merge4); } putchar ('\n'); puts ("======================================================"); putchar ('\n'); getch (); /*屏幕暂留*/ return 0;}运行结果

</len2){

c语言中调用函数的返回值，如果是数组，主函数要输出这个数组怎么实现啊

用指针，另外保存数据的变量退出函数时不得消失。
例如：
#include

int * fun(int n)

{

int i;

static int a[100]; // 这里用static

for (i=0;i
<n;i++) a[i]="i;
return &a[0];

}void main()

{

int i,n=5;

int *p; // 声明指针

p = fun(n); // 返回指针

for (i=0;i
<n;i++) printf("%d\n",p[i]); 把 p 看成数组来输出
}

得 0 1 2 3 4

扩展资料：注意事项

1、数组的维度必须是一个常量表达式

int main(void)

{

constexpr int i = 20;

int j = 5;//不是常量表达式

int arr1[i];//正确

int arr2[j];//错误

system("pause");

return 0;

}

2、默认情况下，数组的元素被默认初始化。

而且需要注意的是，和内置类型的变量一样，如果在函数内部定义了某种内置类型的数组，那么默认初始化会令数组有未定义的值。