第十章 数组和指针

最新推荐文章于 2022-02-24 21:29:32 发布
最新推荐文章于 2022-02-24 21:29:32 发布 · 225 阅读 · 0

 1．修改程序清单10.7中的程序rain，使它不使用数组下标，而是使用指针进行计算（程序中仍然需要声明并初始化数组）

 

#include<stdio.h>
#define MONTHS 12
#define YEARS 5

int main()
{
	const float rain[YEARS][MONTHS]={
		 {4.3,4.3,4.3,3.0,2.0,1.2,0.2,0.2,0.4,2.4,3.5,6.6},
        {8.5,8.2,1.2,1.6,2.4,0.0,5.2,0.9,0.3,0.9,1.4,7.3},
        {9.1,8.5,6.7,4.3,2.1,0.8,0.2,0.2,1.1,2.3,6.1,8.4},
        {7.2,9.9,8.4,3.3,1.2,0.8,0.4,0.0,0.6,1.7,4.3,6.2},
        {7.6,5.6,3.8,2.8,3.8,0.2,0.0,0.0,0.0,1.3,2.6,5.2}
	};
	int year,month;
	float subtot,total;
    const float *rainPtr;
	
	rainPtr = rain[0];
	
	printf("YEAR RAINFALL (inches)\n");
	for(year = 0,total = 0; year < YEARS; year++)
	{
		
		for(month = 0,subtot = 0; month < MONTHS; month++)
		{
			
			subtot += *rainPtr;
		    rainPtr++;
		} 
		printf("200%d %.1f\n",year,subtot);
		total += subtot;
	} 
	printf("\nThe yearly average is %.1f inches.\n",total/MONTHS);
	printf("MONTHLY AVERAGES:\n\n");
 	printf(" Jan  Feb  Mar  Apr  May  Jun  Jul  Aug  Sep  Oct ");
    printf(" Nov  Dec\n");
    
    rainPtr = rain[0]; //reset pointer  
    for(month = 0; month < MONTHS ; month++)
    {
    	rainPtr = rainPtr + month;
    	for(year = 0,subtot = 0; year < YEARS ; year++)
    	{
	    	subtot += *rainPtr;
	    	rainPtr += MONTHS;
	    }
	    rainPtr = rain[0];
	    printf(" %.1f ",subtot/YEARS);
    }
	printf("\n");
	return 0; 
	
}

 

 

2．编写一个程序，初始化一个double数组，然后把数组内容复制到另外两个数组（3个数组都需要在主程序中声明）。制作第一份拷贝的函数使用数组符号。制作第二份拷贝的函数使用指针符号，并使用指针的增量操作。把目标数组名和要复制的元素数目做为参数传递给函数。也就是说，如果给定了下列声明，函数调用应该如下面所示：

 

#include<stdio.h>

#define SIZE 5

void copy_arr(double target1[],double source[],int n);
void copy_ptr(double *target2,double *source,int n);
void display(double *target,int n);

int main()
{
	double source[SIZE]={
		1.1,1.2,1,6.4,7.8
	};
	double target1[SIZE];
	double target2[SIZE];
	
	copy_arr(target1,source,SIZE);
	copy_ptr(target2,source,SIZE);
	
	display(target1,SIZE);
	printf("\n");
	display(target2,SIZE);
	
	printf("\n");
	return 0;
}

void copy_arr(double target1[],double source[],int n)
{
	for(int i=0;i < n;i++)
	{
		target1[i] = source[i];
	}
}
void copy_ptr(double *target2,double *source,int n)
{
	for(int i = 0; i < n; i++)
	{
		//*target2 = *source;
		//source++;
		//target2++;
		*target2++ = *source++;
	}
}
void display(double *target,int n)
{
	for(int i = 0 ; i < n ;i++)
	{
		printf("%2.2f ",*target++);
	//	target++;
	}
}

 

 

 3．编写一个函数，返回一个int数组中存储的最大数值，并在一个简单的程序中测试这个函数。

 

#include<stdio.h>

#define SIZE 5

int select_max(int *ptr,int n);

int main()
{
	int array[SIZE] = {
		1,2,3,4,5
	};
	int max;
	
	max = select_max(array,SIZE);
	printf("max is %d\n",max);
	return 0;
}

int select_max(int *ptr,int n)
{
	int max = *ptr;
	for(int i = 0 ; i < SIZE ; i++)
	{
		if(max < *ptr)
		   max = *ptr;
        ptr++;
	}
	return max;
}

 

 

 4．编写一个函数，返回一个double数组中存储的最大数值的索引，并在一个简单程序中测试这个函数。

#include<stdio.h>

#define SIZE 5

int select_max(int *ptr,int n);

int main()
{
	int array[SIZE] = {
		1,2,3,4,5
	};
	int max_index;
	
	max_index = select_max(array,SIZE);
	printf("max index is %d\n",max_index);
	return 0;
}

int select_max(int *ptr,int n)
{
	int max = *ptr;
	int max_index = 0;
	for(int i = 0 ; i < SIZE ; i++)
	{
		if(max < *ptr)
		{
			 max = *ptr;
			 max_index = i;
		}
		  
        ptr++;
	}
	return max_index;
}

 

 5．编写一个函数，返回一个double数组中最大的和最小的数之间的差值，并在一个简单的程序中测试这个函数。

#include<stdio.h>

#define SIZE 5

int D_value(int *ptr,int n);

int main()
{
	int array[SIZE] = {
		1,2,3,4,5
	};
	int value;
	
	value = D_value(array,SIZE);
	printf("max - min = %d\n",value);
	return 0;
}

int D_value(int *ptr,int n)
{
	int max = *ptr;
	int min = *ptr;
	for(int i = 0 ; i < SIZE ; i++)
	{
		if(max < *ptr )
		{
			 max = *ptr;
		}
		if(min > *ptr)
		 min = *ptr;
  
        ptr++;
	}
	return max-min;
}

 

6．编写一个程序，初始化一个二维double数组，并利用练习2中的任一函数来把这个数组复制到另一个二维数组（因为二维数组是数组的数组，所以可以使用处理一维数组的函数来复制数组的每个子数组）。

#include<stdio.h>
#define SIZE 6

void copy_ptr(double *target1,double *source,int n);
void display(double *target,int n);

int main()
{
	double source[2][3]={
		1.1,1.2,1,6.4,7.8
	};
	double target1[2][3];
	
	copy_ptr(target1[0],source[0],SIZE);
	
	display(target1[0],SIZE);
	printf("\n");
	
	printf("\n");
	return 0;
}
void copy_ptr(double *target1,double *source,int n)
{
	for(int i = 0; i < n; i++)
	{
		//*target2 = *source;
		//source++;
		//target2++;
		*target1++ = *source++;
	}
}
void display(double *target,int n)
{
	for(int i = 0 ; i < n ;i++)
	{
		printf("%2.2f ",*target++);
	//	target++;
	}
}

  7．利用练习2中的复制函数，把—个包含7个元素的数组内第3到第5元素复制到一个包含3个元素的数组中。函数本身不需要修改，只需要选择合适的实际参数（实际参数不需要是数组名和数组大小，而只须是数组元素的地址和需要复制的元素数目）。

#include<stdio.h>

#define SIZE 5
#define TARGET_SIZE 3


void copy_ptr(double *target1,double *source,int n);
void display(double *target,int n);

int main()
{
	double source[SIZE]={
		1.1,1.2,1,6.4,7.8
	};
	double target1[TARGET_SIZE];
	
	copy_ptr(target1,source+2,TARGET_SIZE);
	
	display(target1,TARGET_SIZE);
	printf("\n");
	
	printf("\n");
	return 0;
}
void copy_ptr(double *target1,double *source,int n)
{
	for(int i = 0; i < n; i++)
	{
		*target1++ = *source++;
	}
}
void display(double *target,int n)
{
	for(int i = 0 ; i < n ;i++)
	{
		printf("%2.2f ",*target++);
	//	target++;
	}
}

  8．编写一个程序，初始化一个3x5的二维double数组，并利用一个基于变长数组的函数把该数组复制到另一个二维数组。还要编写。个基于变长数组的函数来显示两个数组的内容。这两个函数应该能够处理任意的NxM数组（如果没有可以支持变长数组的编译器，就使用传统C中处理Nx5数组的函数方法）。

#include<stdio.h>

#define ROW 3
#define COL 5

void copy_ptr(double *target1,double *source,int n);
void copy_arr(double target2[][COL],double source[][COL],int rows);
void display(double target[][COL],int rows);

int main()
{
	double source[ROW][COL] = {
		{1,1.2,4,5.6,7.8},
		{1,1.2,4,5.6,7.8},
		{1,1.2,4,5.6,7.8}
	};
	double target1[ROW][COL],target2[ROW][COL];
	
	copy_ptr(target1[0],source[0],ROW*COL);
	copy_arr(target2,source,ROW);
	
	display(target1,ROW); 
	printf("\n");
	display(target2,ROW); 
	printf("\n");
	return 0;
}
 
 void copy_ptr(double *target1,double *source,int n)
 {
 	for(int i = 0; i < n; i++)
 	   *target1++ = *source++;
 }
void copy_arr(double target2[][COL],double source[][COL],int rows)
{
	for(int i = 0 ; i < rows ; i++)
	   for(int j = 0; j < COL ; j++)
	       target2[i][j] = source[i][j];
	
}
void display(double target[][COL],int rows)
 {
 	for(int i = 0 ; i < rows ; i++)
 	{
	 	for(int j = 0; j < COL ; j++)
	       printf("%2.1f ",target[i][j]);
	   printf("\n");
    }
	  	   
 }

  9．编写一个函数，把两个数组内的相应元素相加，结果存储到第3个数组内。也就是说，如果数组l具有值2、4、5、8，数组2具有值1、0、4、6，则函数对数组3赋值为3、4、9、140函数的参数包括3个数组名和数组大小。并在一个简单的程序中测试这个函数。

#include<stdio.h>

#define SIZE 6

void sum(double *target1,double *target2,double *result,int n);
void display(double *target,int n);

int main()
{
	double source1[SIZE]={
		1.1,1.2,1,6.4,7.8
	};
	double source2[SIZE]={
		1.1,1.2,1,6.4,7.8
	};
	double result[SIZE];
		
	sum(source1,source2,result,SIZE);
	
	display(result,SIZE);
	printf("\n");

	return 0;
}
void sum(double *target1,double *target2,double *result,int n)
{
	for(int i = 0; i < n; i++)
	{
	   result[i] = target1[i] + target2[i];
	}
}
void display(double *target,int n)
{
	for(int i = 0 ; i < n ;i++)
	{
		printf("%2.2f ",*target++);
	//	target++;
	}
}

   10.编写…个程序，声明一个3x5的数组并初始化，具体数值可以随意。程序打印出数值，然后数值翻1番，接着再次打印出新值。编写一个函数来显示数组的内容，再编写另一个函数执行翻倍功能。数组名和数组行数作为参数由程序传递给函数

#include<stdio.h>

#define ROW 3
#define COL 5

void double_arr(double target[][COL],int rows);  //arrry*2
void display(double source[][COL],int rows);

int main()
{
	double source[ROW][COL] = {
		{1,1.2,4,5.6,7.8},
		{1,1.2,4,5.6,7.8},
		{1,1.2,4,5.6,7.8}
	};
	
    display(source,ROW);
	double_arr(source,ROW);	
	printf("\n");
	display(source,ROW); 
	
	printf("\n");
	return 0;
}
 
 
void double_arr(double source[][COL],int rows)
{
	for(int i = 0 ; i < rows ; i++)
	   for(int j = 0; j < COL ; j++)
	       source[i][j] = source[i][j] * 2;
	
}
void display(double source[][COL],int rows)
 {
 	for(int i = 0 ; i < rows ; i++)
 	{
	 	for(int j = 0; j < COL ; j++)
	       printf("%2.1f ",source[i][j]);
	   printf("\n");
    }
	   
	   
 }

  11.重写程序清单10.7的程序rain，main()中的主要功能改为由函数来执行。

#include <stdio.h>

#define MONTHS 12    // number of months in a year
#define YEARS   5    // number of years of data

void every_total(const float source[][MONTHS],int years); //rainfull of every year and total rainfull
void average_month(const float source[][MONTHS],int years);//average rainfull of every month

int main(void)
{
 // initializing rainfall data for 2000 - 2004
    const float rain[YEARS][MONTHS] =
    {
        {4.3,4.3,4.3,3.0,2.0,1.2,0.2,0.2,0.4,2.4,3.5,6.6},
        {8.5,8.2,1.2,1.6,2.4,0.0,5.2,0.9,0.3,0.9,1.4,7.3},
        {9.1,8.5,6.7,4.3,2.1,0.8,0.2,0.2,1.1,2.3,6.1,8.4},
        {7.2,9.9,8.4,3.3,1.2,0.8,0.4,0.0,0.6,1.7,4.3,6.2},
        {7.6,5.6,3.8,2.8,3.8,0.2,0.0,0.0,0.0,1.3,2.6,5.2}
    };
    
    every_total(rain,YEARS);
    average_month(rain,YEARS);
    
    printf("\n");
    return 0;
}

void every_total(const float source[][MONTHS],int years)
{
	printf("YEAR RAINFULL(inches)\n");
	float subtotal,total;
	subtotal = 0;
	total = 0;
	for(int i = 0; i < years ; i++)
	{
		for(int j = 0; j < MONTHS; j++)
		 {
 			subtotal += source[i][j];
 		 }
		printf("200%d %2.1f\n",i,subtotal);   
        total += subtotal;
        subtotal = 0 ; //reset subtotal to 0
	}
	printf("The yearly average is %2.1f inches\n",total/YEARS);
}
void average_month(const float source[][MONTHS],int years)
{
    float sub = 0;
    
    printf("MONTHLY AVERAGES:\n\n");
    printf(" Jan  Feb  Mar  Apr  May  Jun  Jul  Aug  Sep  Oct ");
    printf(" Nov  Dec\n");
    for(int i = 0; i < MONTHS ; i++)
	{
		for(int j = 0; j < years; j++)
		 {
 			sub += source[j][i];
 		 }
		printf(" %2.1f ",sub);   
        sub = 0; //reset sub= 0 
	} 
}
  12.编写…个程序，提示用户输入3个数集，每个数集包括5个double值。程序应当实现下列所有功能：

    a．把输入信息存储到一个3x5的数组中
    b．计算出每个数集（包含5个数值）的平均值
    c．计算所有数值的平均数
    d．找出这15个数中的最大值．
    e．打印出结果
    每个任务需要用一个单独的函数来实现（使用传统C处理数组的方法）。对于任务b，需要编写计算并返回一维数组平均值的函数，循环3次调用该函数来实现任务b。对于其他任务，函数应当把整个数组做为参数，并且完成任务c和d的函数应该向它的调用函数返回答案。

#include<stdio.h>

#define ROWS 3
#define COLS 5

void input_arrays(double source[][COLS],int rows); //input arrays
void average_array(double source[][COLS],double averages[],int rows); //compute the average of every arrays
void average_total(double *source,int rows); //compute average of all arrays
void output_arrays(double source[][COLS],int rows); //output arrays
double max(double source[][COLS],int rows);// find the max one

int main(void)
{
	double source[ROWS][COLS];
	double averages[ROWS];
	
	input_arrays(source,ROWS); //input array
	printf("the array you input is：\n"); 
	output_arrays(source,ROWS); //output array
    average_array(source,averages,ROWS); //compute the average value of each array
	printf("\n the average value of every array is :\n");
	for(int i = 0;i < ROWS ;i++ )
	{
		printf("%.2f ",averages[i]);
	}
	printf("\n the max one is %.2f\n",max(source,ROWS));
	return 0;
}

void input_arrays(double source[][COLS],int rows) //input arrays
{
	printf("please input 3 arrays, 5 counts for each array:\n ");
	for(int i = 0 ; i < rows ; i++)
		for(int j = 0; j < COLS ; j++)
		  scanf("%lf",&source[i][j]);
  
}
//compute the average of every arrays
void average_array(double source[][COLS],double averages[],int rows) 
{
 
	double subtotal = 0;

	for(int i = 0 ; i < rows; i++)
	{
		for(int j = 0 ; j < COLS; j++)
		{
			subtotal += source[i][j];
		}
		averages[i] = subtotal/COLS;
		subtotal = 0; //reset subtotal = 0
	} 
}

//output arrays
void output_arrays(double source[][COLS],int rows) 
{
	
	for(int i = 0 ; i < rows ; i++)
 	{
	 	for(int j = 0; j < COLS ; j++)
	       printf("%.2lf ",source[i][j]);
	   printf("\n");
    }
  
}

double max(double source[][COLS],int rows)
{
	double max = source[0][0];
	for(int i = 0 ; i < rows ; i++)
 	{
	 	for(int j = 0; j < COLS ; j++)
	       if(source[i][j] > max)
	       		max = source[i][j];
  
    }
	return max;
}
 
进阶C语言第十章、数组和指针
Asa的博客
08-12 248
数组 ：由数据类型相同的一系列元素组成。使用数组时，通过声明数组告知编译器数组中有多少元素和这些元素的类型。编译器根据这些信息正确地创建数组。 1、使用逗号分隔的值列表来初始化数组。 2、有时需要把数组设置为只读，const int day [MON]= {1,1,23,32,}; 3、编译器使用的值是内存相应位置上的现在有值，使用数组前必须先赋初值。 4、如果不初始化数组，数组元素和未初始化的普通变量一样，其储存的都是垃圾值。部分初始化，剩余元素就会被初始化为0。可以省略方括号中的数字，让编译器自动.
C Primer Plus 第十章 数组 指针 编程练习答案（自作）
fengqy1996的博客
03-12 508
C Primer Plus 第十章 数组 指针 编程练习答案（自作）
数组的基本操作和一些比较简单的排序算法
zhongyiit的博客
02-24 727
数组的基本操作和一些比较简单的排序算法 假设创建如下数组： double [] mylist=new double[10]; 下面是一些处理数组的例子 随机初始化数组 //使用0.0到100.0之间，但小于100.0的随机初始化数组 for(int i=0;i<mylist.length;i++){ mylist[i]=Math.random()*100; } 使用输入值初始化数组 java.util.Scanner input=new java.util.Scanner(Syst
C语言之经典例题 还不快看
weixin_45699237的博客
05-24 302
1.给定两个数，求这两个数的最大公约数 例如： 输入：20 40 输出：20 #include <stdio.h> #include <windows.h> #pragma warning (disable:4996) int main() { //给定两个数，求这两个数的最大公约数 int a = 0; int b = 0; int c = 0; printf("请输入两个整数："); scanf("%d%d", &a, &b);
关于简单排序中的选择排序为什么采用数组下标进行比较而不是数组元素进行比较的详解
Afterflow_s的博客
03-03 575
**选择排序（Selection sort）**是一种简单直观的排序算法。 它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。 今天在复习简单排序的时候想用数组元素直接进行比较来置换元素，却无法解决问题，反复检查几遍以后发现了问题所在，请大家先过目我写的代码。 public class SelectSort {
打印数组的各个元素 | 用数组下标与不用数组下标
KYG__U_O的博客
08-22 290
用数组下标 #include<stdio.h> void print(int arr[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } } int main() { int arr[] = { 1,2,3,4,5,6 }; int sz = sizeof(arr) / sizeof(arr[0]); print(arr, sz); return 0; } 不.
C语言书籍<<C primer plus>>第十章数组与指针课后习题代码参考(自制)
04-21
《C Primer Plus》是C语言学习的经典教材，其第十章主要讲解了数组和指针这两个核心概念。在C语言中，数组和指针密切相关，它们是理解和掌握C语言底层机制的关键。本压缩包中的资源提供了该章的课后习题代码实现，为...
C第十章（数组和指针）习题
wulimmya的博客
07-31 608
int torf[2][2] = {12, 14, 16};是什么意思 我竟然不确定？？？我个垃圾 #include <stdio.h> int main() { int *ptr; int torf[2][2] = {12, 14, 16}; ptr = torf[0];//指向torf[0][0] return 0; } 就算只写一个元素也...
C Primer Plus 第十章：数组和指针
qq_39670362的博客
04-28 228
10.13 编程练习 修改程序请打10.7的rain.c程序，用指针进行计算。 #include<stdio.h> #define MONTHS 12 #define YEARS 5 int main() { const float rain[YEARS][MONTHS] = { {4.3, 4.3, 4.3, 3.0, 2.0, 1.2, 0.2...
C primer plus 第十章(数组和指针)编程练习--第五版
sunshineddMMZ的博客
05-11 1392
C primer plus 第十章(数组和指针)编程练习–第五版 C 语言编程练习都为本人学习时的编写代码记录或学习笔记，若有不当之处欢迎指正，感激不尽。(其中编程设计也可有其他设计方案，本人目前仅在学习中，所以仅为个人学习记录，仅供参考。) 1．修改程序清单 10.7 中的程序 rain，使它不使用数组下标，而是使用指针进行计算（程序中仍然需要声明并初始化数组）。 /* ra...
用c语言求一组数组的最大值以及最小值
熊尧的专栏
01-03 3万+
#include//stdio.h是c的标准的i/o库，是以函数的方式向buffer写入或读取字符，iostream.h是c++的标准i/o库，引入了输入/输出流的概念，是一个类库，是以类方法从streambuf中读取，写入字符。 int max=0; int min=1000; void change(int a[],int n)  { int i,j,k; for(i=1;i<n;
C/C++ 取整函数ceil(),floor()
热门推荐
倾城一屁，博妹一笑。
11-30 13万+
#include  double floor(double x);  float floorf(float x); long double floorl(long double x); double floor(double x); double ceil(double x); 使用floor函数。floor(x)返回的是小于或等于x的最大整数。 如：     fl
编写一个函数，返回double数组中最大值和最小的数之间的差值
Aricia的博客
12-09 7539
输入 输入包括两行，第一行为数组的大小n，接下来一行输入n个数，以空格隔开 输出 输出数组中最大值与最小值的差，结果保留两位小数 样例输入 3 1 2 5 样例输出 4.00 #include&lt;stdio.h&gt; #define N 400 double CH(double a[],int n); int main() { double a[N]; in...
《C Primer Plus》第十章编程题
silence_nero的专栏
10-18 1314
1、编写一个程序，初始化一个double数组，然后把数组内容复制到另外两个数组（3个数组都需要在主程序中声明）。制作第一份拷贝的函数使用数组符号。制作第二份拷贝的函数使用指针符号，病使用指针的增量操作。把目标数组名和要复制的元素作为参数传递给函数。也就是说，如果给定了下列声明，函数调用应该如下面所示： double source[5]={1.1,2.2,3.3,4.4,5.5}; do
第10章 数组和指针—编程练习
心向往之
06-01 990
1、修改程序清单10.7的rain.c程序，用指针进行计算（仍然要声明并初始化数组）。 //计算每年的总的降水量、年平均降水量、5年中每月的平均降水量 #include <stdio.h> #define MONTHS 12 #define YEARS 5 int main(void) { const float rain[YEARS][MONTHS] = { 4.3,4.3,...
【嵌入式AIoT】系统架构与轻量化模型部署：面向智能家居与工业监测的边缘智能终端实战设计
12-21
内容概要：本文系统介绍了嵌入式AIoT应用场景的实战方法与实践路径，涵盖从场景选择、系统架构设计到AI模型部署、通信与数据管理的全流程。重点阐述了嵌入式系统与人工智能、物联网技术的融合，强调在资源受限环境下实现感知、分析与决策一体化的智能终端系统。文章详细解析了感知层、边缘计算层和云端服务层的协同机制，突出边缘侧数据处理与轻量化AI模型优化的重要性，并倡导以实际需求为导向，避免“为AI而AI”的设计误区。同时，强调系统稳定性、远程维护和长期运行能力的建设。; 适合人群：具备嵌入式系统基础、物联网或AI相关背景，有一定开发经验的工程师或工作1-3年的技术研发人员；适用于希望深入理解AIoT系统集成与实战落地的学习者。; 使用场景及目标：①智能家居、工业监测、智慧农业等分布式智能系统开发；②在算力、功耗受限的嵌入式设备上实现AI推理与边缘智能；③构建高效、可靠、可维护的端云协同AIoT系统。; 阅读建议：建议结合实际硬件平台进行项目化学习，边学边练，重点关注系统架构设计、模型优化与通信协议选型，注重整体系统思维的培养，而非仅关注单一技术点。
基于Python 的UART 文件传输工具
最新发布
12-21
基于Python 的UART 文件传输工具，基于Pyside6的GUI界面
C# 基于 Onnx 与 P2PNet 的人群检测与计数系统源码实现
12-21
基于C#编程语言与Onnx运行时环境，本文档详细阐述了一种利用P2PNet架构实现人群密度估计与个体计数的技术方案。该方案通过解析预训练模型，实现了对图像或视频流中人群分布的精准检测，并提供了可靠的计数功能。核心内容包括模型加载与推理流程的完整实现、数据处理管道的构建以及性能优化策略的探讨。本文旨在为相关领域的开发人员提供一个清晰、可复现的参考实现，着重于工程实践的严谨性与代码模块的可用性。所有实现代码均经过结构化组织与详细注释，以确保其易于理解与集成。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值