严蔚敏数据结构矩阵

已于 2022-05-07 16:32:34 修改
阅读量177 收藏 1
点赞数
文章标签： 数据结构 蓝桥杯 c语言
于 2022-05-07 16:30:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laohuchishizi/article/details/124633573
版权
这篇博客详细介绍了稀疏矩阵的几种存储方式，包括数组的一般存储、三元组存储和十字链表存储，并提供了相应的操作函数，如创建、转置、乘法等。此外，还给出了C语言实现的代码示例，展示了如何读取文件中的矩阵数据并进行运算。
摘要由CSDN通过智能技术生成

头文件array.h

数组的一般存储：

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#define MAXARRAYDIM 8
#define ERROR 0
#define OVERFLOW -1
#define UNDERFLOW 0
#define OK 1
#define TRUE 1
#define FALSE 0
typedef int ElemType;
typedef int Status;
typedef struct
{
	ElemType* base;                                   //数组基地址
	int dim;                                          //数组维数
	int* bounds;                                      //数组维界基址（存储每个维度范围）
	int* constants;                                   //映像函数常量基址（P93 5-2式的ci）
}Array;
Status InitArray(Array* A, int dim, ...)
{
	if (dim<1 || dim>MAXARRAYDIM) return ERROR;
	A->dim = dim;
	A->bounds = (int*)malloc(sizeof(int) * dim);
	if (!A->bounds) exit(OVERFLOW);
	int elemtotal = 1;
	va_list ap;                                       //va_list包含在库stdarg.h中，是可变长
	va_start(ap, dim);                                //度表，从dim开始
	for (int i = 0; i < dim; i++)
	{
		A->bounds[i] = va_arg(ap, int);               //调用该函数后，ap指向下一个参数
		if (A->bounds < 0) return UNDERFLOW;
		elemtotal *= A->bounds[i];
	}
	va_end(ap);                                       //va_start与va_end成对出现
	A->base = (int*)malloc(sizeof(int) * elemtotal);
	if (!A->base) exit(OVERFLOW);
	A->constants = (int*)malloc(sizeof(int) * dim);
	if (!A->constants) exit(OVERFLOW);
	A->constants[dim - 1] = 1;                        //采用递推公式计算映像函数常量
	for (int i = dim - 2; i >= 0; i--)                //从后往前计算，最低维为1
		A->constants[i] = A->constants[i + 1] * A->bounds[i + 1];
	return OK;
}
Status DestroyArray(Array* A)
{
	if (A->base)
		free(A->base);
	A->base = NULL;
	if (A->bounds)
		free(A->bounds);
	A->bounds = NULL;
	if (A->constants)
		free(A->constants);
	A->constants = NULL;
	A->dim = 0;
	return OK;
}
Status Locate(Array A, va_list ap, int* off)
{
	*off = 0;                                          //返回相对基址的地址
	for (int i = 0; i < A.dim; i++)
	{
		int idx = va_arg(ap, int);
		if (idx < 0 || idx >= A.bounds[i])
			return OVERFLOW;
		off += A.constants[i] * idx;
	}
	return OK;
}
Status Value(Array A, ElemType* e, ...)
{
	va_list ap;
	va_start(ap, e);
	int off;
	Locate(A, ap, &off);
	va_end(ap);
	*e = A.base[off];
	return OK;
}
Status Assign(Array* A, ElemType e, ...)
{
	va_list ap;
	va_start(ap, e);
	int off;
	Locate(*A, ap, &off);
	va_end(ap);
	A->base[off] = e;
	return OK;
}

系数矩阵的三元组存储：

#define MAXSIZE 12500
#define MAXRC 100
#define MAXLINELEN 100
#define STACK_INIT_SIZE 100
#define STACKINCREASMENT 10
//用到的栈的数据结构及函数
typedef struct
{
	ElemType* base, * top;
	int stacksize;
}SqStack;
Status InitStack(SqStack* S)
{
	S->base = (ElemType*)malloc(sizeof(ElemType) * STACK_INIT_SIZE);
	if (!S->base) exit(OVERFLOW);
	S->top = S->base;
	S->stacksize = STACK_INIT_SIZE;
	return OK;
}
Status Push(SqStack* S, ElemType e)
{
	if (S->top - S->base == STACK_INIT_SIZE)
		S->base = (ElemType*)realloc(S->base, sizeof(ElemType) * STACKINCREASMENT);
	S->stacksize += STACKINCREASMENT;
	*(S->top) = e;
	S->top++;
	return OK;
}
Status Pop(SqStack* S, ElemType* e)
{
	if (S->base == S->top)
		return ERROR;
	S->top--;
	*e = *(S->top);
	return OK;
}
Status StackEmpty(SqStack S)
{
	if (S.base == S.top)
		return TRUE;
	else
		return FALSE;
}
//三元组表示系数矩阵
typedef struct
{
	int i, j;
	ElemType e;
}Triple;
typedef struct
{
	Triple data[MAXSIZE];
	int mu, nu, tu;
}TSMatrix;
Status TransposeSMatrix(TSMatrix M, TSMatrix* T)    //一般方法求稀疏矩阵的转置
{                                                   //顺序扫描所有的元素
	T->mu = M.nu;                                   //由于要从T的第一行开始赋值，就要找到
	T->nu = M.mu;                                   //M中列号为1的元素，以此类推
	T->tu = M.tu;                                   //以此类推复杂度为O（M.nu*M.tu）
	if (T->tu)
	{
		int q = 1;
		for (int col = 1; col <= M.nu; col++)
			for (int j = 1; j <= M.tu; j++)
				if (M.data[j].j == col)
				{
					T->data[q].i = M.data[j].j;
					T->data[q].j = M.data[j].i;
					T->data[q].e = M.data[j].e;
					q++;
				}
	}
	return OK;
}
Status FastTransposeSMatrix(TSMatrix M, TSMatrix* T)
{                                                    //快速转置矩阵的方法
	T->mu = M.nu;                                    //用num数组记录M中不同列中的非零元数量
	T->nu = M.mu;                                    //用cpot数组记录遇到M中列号为col的元素
	T->tu = M.tu;                                    //应该赋到T的什么位置
	if (T->tu)
	{
		int* num, * cpot;
		num = (int*)malloc(sizeof(int) * (M.nu + 1));
		if (!num) exit(OVERFLOW);
		cpot = (int*)malloc(sizeof(int) * (M.nu + 1));
		if (!cpot) exit(OVERFLOW);
		for (int i = 1; i <= M.mu; i++)
			num[i] = 0;
		for (int i = 1; i < M.tu; i++)
			num[M.data[i].j]++;
		cpot[1] = 1;
		for (int i = 2; i < M.nu; i++)
			cpot[i] = cpot[i - 1] + num[i - 1];
		for (int i = 1; i <= T->tu; i++)
		{
			int col = M.data[i].j;
			int j = cpot[col];
			T->data[j].e = M.data[i].e;
			T->data[j].i = M.data[i].j;
			T->data[j].j = M.data[i].i;
			cpot[i]++;
		}
	}
	return OK;
}
//行逻辑稀疏矩阵（在三元组稀疏矩阵的基础上加入了每行第一个非零元的位置）
typedef struct
{
	Triple data[MAXSIZE + 1];
	int mu, nu, tu;
	int rpos[MAXRC + 1];
}RLSMatrix;
Status MultSMatrix(RLSMatrix M, RLSMatrix N, RLSMatrix* Q)
{
	if (M.nu != N.mu)
		return ERROR;
	Q->mu = M.mu;
	Q->nu = N.nu;
	int* temp;
	temp = (int*)malloc(sizeof(int) * (N.nu + 1));
	if (!temp) exit(OVERFLOW);
	Q->tu = 0;
	if (M.tu * N.tu != 0)
	{
		for (int mrow = 1; mrow <= M.mu; mrow++)
		{
			Q->rpos[mrow] = Q->tu + 1;
			for (int i = 1; i <= N.nu; i++)
				temp[i] = 0;
			int mst, men;
			mst = M.rpos[mrow];
			if (mrow == M.mu)
				men = M.tu;
			else
				men = M.rpos[mrow + 1] - 1;
			for (int p = mst; p <= men; p++)
			{
				int nrow = M.data[p].j;
				int nst = N.rpos[nrow], nen;
				if (nrow == N.mu)
					nen = N.tu;
				else
					nen = N.rpos[nrow + 1] - 1;
				for (int q = nst; q <= nen; q++)
				{
					int col = N.data[q].j;
					temp[col] += N.data[q].e * M.data[p].e;
				}
			}
			Q->rpos[mrow] = Q->tu + 1;
			for (int i = 1; i <= N.nu; i++)
			{
				if (temp[i])
				{
					if (++Q->tu > MAXSIZE) return ERROR;
					Q->data[Q->tu].e = temp[i];
					Q->data[Q->tu].i = mrow;
					Q->data[Q->tu].j = i;
				}
			}
		}
	}
	return OK;
}
void InitRLSMatrix(RLSMatrix* M)
{
	printf("请输入数组的非零元个数\n");
	scanf("%d", &M->tu);
	printf("请输入数组的行数\n");
	scanf("%d", &M->mu);
	printf("请输入数组的列数\n");
	scanf("%d", &M->nu);
	int* rcount;
	rcount = (int*)malloc(sizeof(int) * (M->mu + 1));
	if (!rcount) exit(OVERFLOW);
	for (int i = 1; i <= M->mu; i++)
		rcount[i] = 0;
	for (int i = 1; i <= M->tu; i++)
	{
		printf("请输入第%d个非零元的行号\n", i);
		scanf("%d", &M->data[i].i);
		rcount[M->data[i].i]++;
		printf("请输入第%d个非零元的列号\n", i);
		scanf("%d", &M->data[i].j);
		printf("请输入第%d个非零元的值\n", i);
		scanf("%d", &M->data[i].e);
	}
	M->rpos[1] = 1;
	for (int i = 2; i <= M->mu; i++)
		M->rpos[i] = M->rpos[i - 1] + rcount[i - 1];
}
void Convert_char_int(int* no, char* p)
{
	int i;
	switch (*p)
	{
	case '0':i = 0; break;
	case '1':i = 1; break;
	case '2':i = 2; break;
	case '3':i = 3; break;
	case '4':i = 4; break;
	case '5':i = 5; break;
	case '6':i = 6; break;
	case '7':i = 7; break;
	case '8':i = 8; break;
	default:i = 9;
	}
	*no = i;
}
void FInitRLSMatrix(RLSMatrix* M, FILE* fp, char* buf)
{                                               //从文件中获取信息并建立矩阵
	int row = 0, count = 0;                     //*buf为文件读取缓冲区指针
	SqStack* S;
	S = (SqStack*)malloc(sizeof(SqStack));
	if (!S) exit(OVERFLOW);
	InitStack(S);
	while (!feof(fp))
	{
		M->rpos[row + 1] = count + 1;
		fgets(buf, MAXLINELEN, fp);
		char* ch = buf;
		int col = 0;
		int bit, ans;
		while (*ch != '\n' && *ch != '\0')
		{
			int tag = 0;
			ans = 0;
			int power = 1;
			while (*ch >= '0' && *ch <= '9')
			{
				Convert_char_int(&bit, ch);
				Push(S, bit);
				ch++;
				tag = 1;
			}
			while (!StackEmpty(*S))
			{
				Pop(S, &bit);
				ans += power * bit;
				power *= 10;
			}                                        //将获取到的连续的数字字符转换为int
			if (ans)
			{
				M->data[++count].i = row + 1;
				M->data[count].j = col + 1;
				M->data[count].e = ans;
			}
			if (tag)
				col++;
			ch++;
		}
		row++;
		M->nu = col;
	}
	M->mu = row;
	M->tu = count;
}
void PrintRLSMtrix(RLSMatrix M)
{
	int count = 1;
	for (int i = 1; i <= M.mu; i++)
	{
		for (int j = 1; j <= M.nu; j++)
		{
			if (M.data[count].i == i && M.data[count].j == j)
			{
				printf("%d\t", M.data[count].e);
				count++;
			}
			else
				printf("%d\t", 0);
		}
		printf("\n");
	}
}

十字链表存储：

//十字链表（Orthogonal Link List）
typedef struct OLNode
{
	int i, j;
	ElemType e;
	struct OLNode* right, * down;
}OLNode, * OLink;
typedef struct
{
	OLink* rhead, * chead;
	int mu, nu, tu;
}CrossList;
Status CreateSMatrix_OL(FILE* fp, CrossList* M)
{
	int rowcount = 0, colcount = 0;
	char* buf, * ch;
	buf = (char*)malloc(sizeof(char) * MAXLINELEN);
	if (!buf) exit(OVERFLOW);
	while (!feof(fp))
	{
		rowcount++;
		fgets(buf, MAXLINELEN, fp);
	}
	rewind(fp);
	fgets(buf, MAXLINELEN, fp);
	ch = buf;
	while (*ch != '\0' && *ch != '\n')
	{
		int tag = 0;
		while ((*ch >= '0' && *ch <= '9') || (*ch == '-'))
		{
			ch++;
			tag = 1;
		}
		if (tag)
			colcount++;
		ch++;
	}
	rewind(fp);
	M->mu = rowcount;
	M->nu = colcount;
	M->rhead = (OLink*)malloc(sizeof(OLink) * (M->mu + 1));
	if (!M->rhead) exit(OVERFLOW);
	M->chead = (OLink*)malloc(sizeof(OLink) * (M->nu + 1));
	if (!M->rhead) exit(OVERFLOW);
	for (int i = 1; i <= M->mu; i++)
		M->rhead[i] = NULL;
	for (int i = 1; i <= M->nu; i++)
		M->chead[i] = NULL;
	SqStack* S;
	S = (SqStack*)malloc(sizeof(SqStack));
	if (!S) exit(OVERFLOW);
	InitStack(S);
	int bit, ans, power;
	OLink e;
	int row = 0, col;
	int count = 0;
	int verse;
	while (!feof(fp))
	{
		row++;
		col = 0;
		fgets(buf, MAXLINELEN, fp);
		ch = buf;
		while (*ch != '\0' && *ch != '\n')
		{
			verse = 0;
			int tag = 0;
			ans = 0;
			power = 1;
			while ((*ch >= '0' && *ch <= '9') || (*ch == '-'))
			{
				if (*ch == '-')
					verse = 1;
				else
				{
					Convert_char_int(&bit, ch);
					Push(S, bit);
				}
				ch++;
				tag = 1;
			}
			while (!StackEmpty(*S))
			{
				Pop(S, &bit);
				ans += power * bit;
				power *= 10;
				if (verse == 1)
					ans *= (-1);
			}
			ch++;
			if (tag)
				col++;
			if (ans)
			{
				e = (OLink)malloc(sizeof(OLNode));
				if (!e) exit(OVERFLOW);
				e->e = ans;
				e->i = row;
				e->j = col;
				e->right = NULL;
				e->down = NULL;
				OLink p = M->rhead[row];
				if (!p)
					M->rhead[row] = e;
				else
				{
					while (p->right && p->right->j < e->j)
						p = p->right;
					e->right = p->right;
					p->right = e;
				}
				p = M->chead[col];
				if (!p)
					M->chead[col] = e;
				else
				{
					while (p->down && p->down->i < e->i)
						p = p->down;
					e->down = p->down;
					p->down = e;
				}
				count++;
			}
		}
	}
	M->tu = count;
	return OK;
}
void PrintSMatrix_OL(CrossList M)
{
	for (int i = 1; i <= M.mu; i++)
	{
		OLNode* p = M.rhead[i];
		int j = 1;
		while (p && j <= M.nu)
		{
			if (j == p->j)
			{
				printf("%d\t", p->e);
				p = p->right;
			}
			else
				printf("0\t");
			j++;
		}
		while (j <= M.nu)
		{
			printf("0\t");
			j++;
		}
		printf("\n");
	}
}
Status SumSMatrix_OL(CrossList* M, CrossList N)
{
	if (M->mu != N.mu || M->nu != N.nu)
		return ERROR;
	OLNode* pa, * pre, * pb;
	OLink* hl;
	hl = (OLink*)malloc(sizeof(OLink) * (M->nu + 1));
	if (!hl) exit(OVERFLOW);
	for (int j = 1; j <= M->nu; j++)
		hl[j] = M->chead[j];
	int row = 1;
	while (row <= M->mu)
	{
		pa = M->rhead[row];
		pre = NULL;
		pb = N.rhead[row];
		OLNode* q;
		while (pb)
		{
			if (pa == NULL || pa->j > pb->j)
			{
				q = (OLNode*)malloc(sizeof(OLNode));
				if (!q) exit(OVERFLOW);
				*q = *pb;
				if (pre)
					pre->right = q;
				else
					M->rhead[row] = q;
				q->right = pa;
				pre = q;
				if (M->chead[q->j] && M->chead[q->j]->i < q->i)
				{
					while (hl[q->j]->down->i < q->i)
						hl[q->j] = hl[q->j]->down;
					q->down = hl[q->j]->down;
					hl[q->j]->down = q;
					hl[q->j] = q;
				}
				else
				{
					q->down = M->chead[q->j];
					M->chead[q->j] = q;
				}
				pb = pb->right;
				M->tu++;
			}
			else
			{
				if (pa->j < pb->j)
				{
					pre = pa;
					pa = pa->right;
				}
				else
				{
					if (pa->e + pb->e != 0)
					{
						pa->e += pb->e;
						pre = pa;
						pa = pa->right;
						pb = pb->right;
					}
					else
					{
						q = pa;
						if (pre == NULL)
						{
							M->rhead[row] = pa->right;
							pa = pa->right;
						}
						else
						{
							pa = pa->right;
							pre->right = pa;
						}
						if (q->i == M->chead[q->j]->i)
						{
							M->chead[q->j] = q->down;
							hl[q->j] = q->down;
						}
						else
							hl[q->j]->down = q->down;
						free(q);
						pb = pb->right;
						M->tu--;
					}
				}
			}
		}
		row++;
	}
}

c文件：（仅运行十字链表矩阵相加函数）

#include "array.h"
int main()
{
	FILE* fp, * fq;
	fp = fopen("C:\\Users\\14164\\Desktop\\arrayname1.txt", "r");
	fq = fopen("C:\\Users\\14164\\Desktop\\arrayname2.txt", "r");
	CrossList M;
	CrossList N;
	CreateSMatrix_OL(fp, &M);
	printf("矩阵1：\n");
	PrintSMatrix_OL(M);
	CreateSMatrix_OL(fq, &N);
	printf("矩阵2：\n");
	PrintSMatrix_OL(N);
	SumSMatrix_OL(&M, N);
	printf("矩阵3：\n");
	PrintSMatrix_OL(M);
	return 0;
}

文件中的数组：

 

结果：

哆啦BCD梦
关注
数据结构（C语言版）严蔚敏算法 邻接矩阵C++实现
chenglei12的博客
03-12 1580
图邻接矩阵创建二级目录三级目录 邻接矩阵创建 二级目录 三级目录 下面展示一些 内联代码片。 #include<iostream> using namespace std; #define Maxint 32767 #define Maxver 20 typedef int Vertype; typedef int Edgetype; class Graph { private: Vertype verlist[Maxver]; Edgetype edgelist[Maxver][Maxv
数据结构入门----数组和广义表的概念及应用
qq1457346557的博客
07-08 2704
已经学过的线性表：数据元素都是非结构的原子类型。 数组和广义表的特点：一种特殊的线性表 ① 元素的值并非原子类型，可以再分解，表中元素也是一个线性表（即广义的线性表）。即数据元素本身也是一个数据结构。 ② 所有数据元素仍属同一数据类型。 数组的定义 数组： 由一组名字相同、下标不同的变量构成。 一维数组的特点：1个下标，ai 是ai+1的直接前驱 二维数组的特点：2个下标，每个元素ai,j受到两个关系（行关系和列关系）的约束： 一个m×n的二维数组可以看成是m行的一维数组，或者n列的一维
数据结构笔记——数组
Wmiracle的博客
11-21 881
本篇包括数组的类型定义、数组的顺序表示的代码实现、特殊矩阵的压缩存储，内容综合各方资料及本人的理解将数组的基础理论整合而成。
C++ : 可变参数 va_list ,va_start ,va_arg 的使用方法
superSmart_Dong的博客
08-12 1384
exemple; #include <iostream> #include "sdstructure/linearlist/array.cpp" using namespace std; using namespace SmartDongLib; void show(int dim,...){ va_list ap; va_start(ap,dim); for (int i = 0; i < dim ; ++i) { cout<<.
第五章 数组的数组的顺序存储表示和实现
mazhuang521的博客
11-22 1038
代码能够实现但是会出现非法访问地址。 // Array.cpp : Defines the entry point for the console application. //稀疏矩阵三元组顺序表示的基本操作的实现并完成快速转置 //--------------------------------------------------- //----------------数组的顺序存储表
严蔚敏数据结构ppt
09-27
《严蔚敏数据结构》是计算机科学领域中经典的数据结构教程，主要涵盖了数据结构的基本概念、类型、操作以及它们在算法设计中的应用。这门课程通常包括数组、链表、栈、队列、树、图、散列、排序和查找等核心主题。...
严蔚敏数据结构PPT_严蔚敏_algorithm_
10-01
《严蔚敏数据结构PPT_严蔚敏_algorithm_》是一部深入探讨算法和数据结构的珍贵教学资源，由著名计算机教育家严蔚敏教授精心编撰。这份PPT材料是学习计算机科学与技术领域的基石，涵盖了数据结构的核心概念、设计与...
严蔚敏数据结构课本源码及习题解析.zip
05-21
《严蔚敏数据结构》是一本经典的教材，广泛用于大学计算机专业的教学。该压缩包包含的源码和习题解析为学习者提供了丰富的实践材料，有助于深入理解和掌握数据结构的原理与应用。 源码部分： 严蔚敏教授的教材中...
严蔚敏 数据结构(C语言版) 代码 23490 书中算法
04-21
所属分类：本科 >> 计算机类 >> 数据结构与算法 所属丛书：21世纪高等学校计算机规划教材——名家系列 定　价：￥28.00元 第1章　绪论　1 1.1　数据结构的研究内容　1 1.2　基本概念和术语　3 1.2.1　数据、...
数据结构（严蔚敏版）
02-16
严蔚敏教授编著的《数据结构》是一本广泛被采用的经典教材，深受广大计算机专业学生和研究人员的青睐。这本书深入浅出地介绍了各种常用的数据结构以及它们的算法实现，对于理解和掌握数据结构的基础知识具有极大的...
数组原理（数据结构）
cjj
08-13 1610
目录数组的定义顺序存储表示和实现存储方式存储结构基本操作生成给定维度和维界的数组销毁数组存入元素取出元素 数组的定义 在c语言中，一个二位数组可以定义为一个一维数组类型分量的一位数组，即： typedef ElemType Array[m][n]; 等价于： typedef ElemType Array[m]; typedef Array1[n]; 需要注意，数组一旦被定义，它的维数和维界就不再改变，除了初始化和销毁之外，数组只有存取和修改元素值的操作； 顺序存储表示和实现 存储方式 以行序为主 以列
数据结构-多维数组的实现
suliangkuanjiayou的博客
11-09 4960
写给自己的话：在之前写代码的过程中，我还没有遇到过要自己设计一个可变参数的函数。但是，数据结构中多维数组中，我就不得不去面对这个难题了。说实话，我一开始没有打算写这篇博客的。但是，我看到我的同学（我之前和他讲了这个代码）还在深入研究这个可变参数，我觉得自己也得把它弄得清楚一些，可不能半吊子了！ 回归正题，相信大家书本上一定会给大家介绍四个类型va_list,va_start,va_arg,va_e...
5.1数组的定义&5.2数组的顺序表示和实现
IT1995的博客
02-08 7362
5.1数组的定义&5.2数组的顺序表示和实现
数组的存储结构c语言,数据结构之数组（C语言实现）
weixin_36063465的博客
05-17 1774
数组是大家很熟悉的一种数据类型，而且在我们的程序设计中也应用非常广泛。这里以抽象数据类型的形式讨论数组的定义和实现。一、数组的定义假设n维数组中含有第i维的长度为b(i)，则数组的总长度为b(0) *b(1)*...*b(n-1)，每个元素都受着n个关系的约束。在每个关系中元素a(j1,j2,...,jn) (0<=jn<=b(i)-2)都有一个直接后继元素。因此，就单个关系而言，这n...
va_start和va_end使用详解
weixin_33725270的博客
05-07 862
　　本文主要介绍va_start和va_end的使用及原理。　　在以前的一篇帖子Format MessageBox 详解中曾使用到va_start和va_end这两个宏，但对它们也只是泛泛的了解。　　介绍这两个宏之前先看一下C中传递函数的参数时的用法和原理： 1.在C中，当我们无法列出传递函数的所有实参的类型和数目时,可以用省略号指定参数表void foo(...);void foo(parm_l...
va_start、va_end、va_list的使用
Alan_Chen_2011的专栏
03-19 594
1:当无法列出传递函数的所有实参的类型和数目时,可用省略号指定参数表 void foo(...); void foo(parm_list,...);   2:函数参数的传递原理 函数参数是以数据结构:栈的形式存取,从右至左入栈.eg: #include void fun(int a, ...) {      int *temp =      &a;      te
数组的顺序存储表示
deason6975的专栏
05-11 471
参考书籍:    作者:严蔚敏      p93~94#include "stdio.h"#include "stdarg.h"#define MAX_ARRAY_DIM  8typedef int ElemType;typedef int Status;typedef struct{  ElemType *base;  int dim;  int *bounds;  int *constan
va_start()，va_end()函数应用
a97290137的专栏
12-18 450
原理解释： VA_LIST 是在C语言中解决变参问题的一组宏，在头文件下。 VA_LIST的用法：            （1）首先在函数里定义一具VA_LIST型的变量，这个变量是指向参数的指针       （2）然后用VA_START宏初始化变量刚定义的VA_LIST变量，这个宏的第二个参数是第一个可变参数的前一个参数，是一个固定的参数。       （3）然后用VA_ARG返回可
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值