c语言函数调用数组 c语言代码大全及其含义
大家好，今天给各位分享c语言函数调用数组的一些知识，其中也会对c语言代码大全及其含义进行解释，文章篇幅可能偏长，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在就马上开始吧！
c语言函数怎么调用数组
在C语言中，函数可以通过指针接收数组参数，从而访问和操作数组元素。以下是详细说明和示例：
核心机制地址传递数组作为参数传递时，实际传递的是数组首元素的地址（指针）。由于数组名在大多数表达式中会退化为指针，直接传递数组名即可。
函数声明使用指针参数接收数组，通常需额外传递数组长度（因指针本身不包含长度信息）：
void func(int*arr, int size);//推荐方式//或等价写法（数组形式声明，实际仍为指针）void func(int arr[], int size);关键操作访问元素通过指针算术或数组下标语法访问元素（两者等价）：
int first=*arr;//解引用获取首元素（等同于 arr[0]）int second=*(arr+1);//指针算术访问（等同于 arr[1]）修改原数组函数内通过指针修改元素会直接影响原数组：
void double_elements(int*arr, int size){ for(int i= 0; i< size; i++){ arr[i]*= 2;//直接修改原数组}}完整示例#include<stdio.h>//函数接收数组指针和长度void print_array(int*arr, int size){ for(int i= 0; i< size; i++){ printf("%d", arr[i]);//通过下标访问} printf("n");}int main(){ int arr[]={10, 20, 30, 40, 50}; int size= sizeof(arr)/ sizeof(arr[0]);//计算数组长度 print_array(arr, size);//传递数组名（首地址） return 0;}输出：10 20 30 40 50
注意事项边界保护函数内无法直接获取数组长度，必须显式传递长度参数，否则可能越界访问。
多维数组多维数组需明确指定除第一维外的尺寸（因指针退化）：
void process_2d(int arr[][3], int rows);//列数必须指定const修饰符若函数不应修改数组，可用const保护：
void read_only(const int*arr, int size);总结C语言中函数通过指针操作数组，需注意地址传递的特性。正确管理数组长度和边界是安全编程的关键。
用C语言如何使用函数调用来做一维数组排序谢谢了
f(T a[], int n){}
你要用哪种排序？
#include<stdlib.h>
#include<stdio.h>
#include<time.h>
void InsertSort(int L[]){
//对顺序表L作直接插入排序
int i,j;
for(i= 2; i<= 100;++i)
if(L[i]< L[i-1]){
L[0]= L[i];
for(j= i-1; L[0]< L[j];--j)
L[j+1]= L[j];
L[j+1]= L[0];
}
}// InsertSort
void BInsertSort(int L[]){
//对顺序表L作折半插入排序
int i,j,high,low,m;
for(i= 2; i<= 100;++i){
L[0]= L[i];
low= 1; high= i-1;
while(low<= high){
m=(low+high)/ 2;
if(L[0]< L[m]) high= m-1;
else low= m+ 1;
}
for(j= i-1; j>= high+1;--j) L[j+1]= L[j];
L[high+1]= L[0];
}
}// BInsertSort
void ShellInsert(int L[], int dk){
//对顺序表L作一趟希尔插入排序
int i,j;
for(i= dk+1; i<= 100;++i)
if(L[i]< L[i-dk]){
L[0]= L[i];
for(j= i-dk; j>0&& L[0]<L[j]; j-=dk)
L[j+dk]= L[j];
L[j+dk]= L[0];
}
}// ShellInsert
void ShellSort(int L[]){
//按增量序列dlta[0..t-1]对顺序表L作希尔排序
int dlta[6]={50,25,12,6,3,1};
for(int k= 0; k< 6;++k)
ShellInsert(L, dlta[k]);
}// ShellSort
Partition(int L[], int low, int high){
//交换顺序表L中子序列L.r[low..high]的记录，使枢轴记录到位，
//并返回其所在位置，此时，在它之前（后）的记录均不大（小）于它
L[0]= L[low];
while(low< high){
while(low< high&& L[high]>= L[0])--high;
L[low]= L[high];
while(low< high&& L[low]<= L[0])++low;
L[high]= L[low];
}
L[low]= L[0];
return low;
}// Partition
void QSort(int L[], int low, int high){
//对顺序表L中的子序列L.r[low..high]进行快速排序
int pivotloc;
if(low< high){
pivotloc= Partition(L, low, high);
QSort(L, low, pivotloc-1);
QSort(L, pivotloc+1, high);
}
}// QSort
void QuickSort(int L[]){
//对顺序表L进行快速排序
QSort(L, 1, 100);
}// QuickSort
void SelectSort(int L[]){
//对顺序表L作简单选择排序
int i,j,k;
for(i=1; i< 100; i++){
k= i;
for(j= i+1; j<= 100; j++)
if(L[j]< L[k]) k=j;
if(k!=j)
{L[0]= L[k]; L[k]= L[i]; L[i]=L[0];}
}
}// SelectSort
void HeapAdjust(int H[], int s, int m){
//已知H.r[s..m]中记录的关键字除H.r[s].key之外均满足堆的定义，
//本函数调整H.r[s]的关键字，使H.r[s..m]成为一个大顶堆
int j,rc;
rc= H[s];
for(j= 2*s; j<= m; j*= 2){
if(j< m&& H[j]< H[j+1])++j;
if(rc>= H[j]) break;
H[s]= H[j]; s= j;
}
H[s]= rc;
}// HeapAdjust
void HeapSort(int H[]){
//对顺序表H进行堆排序
int i,temp;
for(i= 50; i> 0;--i)
HeapAdjust( H, i, 100);
for(i= 100; i> 1;--i){
temp=H[i];
H[i]=H[1];
H[1]=temp;
HeapAdjust(H, 1, i-1);
}
}// HeapSort
void Merge(int SR[], int TR[], int i, int m, int n){
//将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]
int j,k;
for(j= m+1, k= i; i<= m&& j<= n;++k){
if(SR[i]<= SR[j]) TR[k]= SR[i++];
else TR[k]= SR[j++];
}
if(i<= m)
while(k<= n&& i<= m) TR[k++]= SR[i++];
if(j<= n)
while(k<= n&& j<= n) TR[k++]= SR[j++];
}// Merge
void MSort(int SR[], int TR1[], int s, int t){
//将SR[s..t]归并排序为TR1[s..t]
int m,TR2[101];
if(s== t) TR1[t]= SR[s];
else{
m=(s+t)/2;
MSort(SR,TR2,s,m);
MSort(SR,TR2,m+1,t);
Merge(TR2,TR1,s,m,t);
}
}// MSort
void MergeSort(int L[]){
//对顺序表L作归并排序
MSort(L, L, 1, 100);
}// MergeSort
void BubbleSort(int L[]){
//对顺序表L作冒泡排序
int i,j,fini= 0;
for(i= 1; i< 100&&!fini; i++){
fini= 1;
for(j= 1; j<= 100-i; j++)
if(L[j]> L[j+1]){
L[0]= L[j];
L[j]= L[j+1];
L[j+1]= L[0];
fini= 0;
}
}
}
void DblPPSort(int L[],int low,int high){
int i,j,fini= 0;
while(low< high){
fini= 1;
for(i= low; i<=high; i++)
if(L[i]> L[i+1]){
L[0]= L[i];
L[i]= L[i+1];
L[i+1]= L[0];
fini= 0;
}
if(fini) break;
high--;
for(i= high; i>=low; i--)
if(L[i]> L[i+1]){
L[0]= L[i];
L[i]= L[i+1];
L[i+1]= L[0];
fini= 0;
}
if(fini) break;
low++;
}
}
void DblBbbSort(int L[]){
//对顺序表L作双向冒泡排序
DblPPSort(L,1,99);
}
void main(){
int i,a[101];
srand(time(NULL));
puts("自动生成100个随机数:");
for(i= 1; i<= 100; i++){
a[i]= rand()%100+ 1;
printf("%3d",a[i]);
if(i%10==0) putchar('\n');
}
puts("选择排序法:\n"
"1:直接插入排序\n"
"2:折半插入排序\n"
"3:Shell插入排序\n"
"4:快速排序\n"
"5:简单选择排序\n"
"6:堆排序\n"
"7:归并排序\n"
"8:冒泡排序\n"
"9:双向冒泡排序");
scanf("%d",&i);
puts("排序结果:");
switch(i){
case 1:InsertSort(a);break;//直接插入排序
case 2:BInsertSort(a);break;//折半插入排序
case 3:ShellSort(a);break;//Shell插入排序
case 4:QuickSort(a);break;//快速排序
case 5:SelectSort(a);break;//简单选择排序
case 6:HeapSort(a);break;//堆排序
case 7:MergeSort(a);break;//归并排序
case 8:BubbleSort(a);break;//冒泡排序
case 9:DblBbbSort(a);break;//双向冒泡排序
}
for(i= 1; i<= 100; i++){
printf("%3d",a[i]);
if(i%10==0) putchar('\n');
}
getchar();getchar();
}
C语言怎么让“函数”返回“指针数组”
你好
从问题来看，似乎你对于指针的概念没太理解。指针变量中存储的是内存中的地址，而实际的数据放在这个地址中。
按照这段代码来说，int*声明的指针指向内存中的一块地址，而在这块地址中存储着一个整形数值。所以要返回这样的值，也就相当于是返回一个内存地址。因此，在程序中有两种具体的解决办法：
1.在调用函数的时候，直接将变量的指针（即内存地址）作为参数传入，在函数执行的时候，就会自动对内存中相应地址的数据进行操作。使用这种方法也就不需要返回值了。具体到这段代码中，就是在Main中声明int* tempA[10]，把foo函数声明为void foo(int* a[10])，调用时用foo(tempA)，在foo函数中直接使用a[10]即可。
2.直接把内存地址作为返回值，因为在C中，数组名就是数组首元素的指针，因此直接返回数组名就可以了，即return a即可。如果是普通变量，要用取内存地址的运算符&，比如声明了整型变量 int i，就可以return&i。这与printf函数中的使用方法是相通的。
【按照补充的内容：】
a-------->a1-------->i1
|-------->a2-------->i2
|……………………
|-------->an-------->im
这样的调用方法，只能保证a1-an不被修改，怎么保证i1-im不被修改？
希望以上回答能帮到你。【PS.很久没用C了，如果哪里出了差错，请指正。】
OK，本文到此结束，希望对大家有所帮助。