首页 / C语言 / C语言指针与数组的定义与声明易错分析

C语言指针与数组的定义与声明易错分析

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C语言指针与数组的定义与声明易错分析，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10311字，纯文字阅读大概需要15分钟。

内容图文

部分摘自《C语言深度解剖》

1.定义为数组，声明为指针

在文件1中定义：

char a[100];

在文件2中声明：

extern char *a;　　//这样是错误的

这里的extern告诉编译器a这个名字已经在别的文件中被定义了，下面的代码使用的a是在别的文件中定义的。编译器是按文件分别编译的，当a被声明为char* a时，编译器理所当然的认为a是一个指针变量，在32位系统下占用4个byte,这4个byte存放的是地址，地址指向的空间存储的是char类型数据。

程序会返回SIGSEGV。

2.定义为指针，声明为数组

文件1：char* p="abcdefg";

文件2：extern char p[];　　//这样也是错误的

在文件1中，编译器分配4个byte空间，并命名为p。同时p里面保存了字符串常量“abcdefg”的首字符地址。这个字符串常量本身保存在内存的静态区，其内容不可修改。在文件2中，编译器认为p是一个数组，其大小为4byte,数组保存的是char类型数据。

技术分享

总结：代码在一个地方定义为指针，在别的地方也只能声明为指针；同理数组。

指针数组与数组指针

指针数组：首先它是一个数组，数组的元素都是指针。

数组指针：首先它是一个指针，指针指向一个数组。

[]比*优先级高

A) int *p1[10]; => (int *)p1[10]; 即它首先是一个数组，数组的元素都是int*;

B) int (*p2)[10]; 首先它是一个指针，指针指向一个包含10个元素的数组；

A:指针数组 B:数组指针

技术分享

main()
{
    char a[5]={‘A‘,‘B‘,‘C‘,‘D‘};
    char (*p3)[5]=&a;	//数组指针
    char (*p4)[5]=a;      	//会产生警告:从不兼容的指针类型初始化
    char (*p5)[3]=&a;	//waring
    char (*p6)[3]=a;	        //waring
    char (*p7)[10]=&a;	//waring
    char (*p8)[10]=a;    	//waring
}

技术分享

对上面五个警告做下分析：

警告1：左值为元素个数为5的数组指针，但是右值是指向元素第一个元素首地址的指针，类型不符；

警告2：左值为元素个数为3的数组指针，但是右值是指向含5个元素的整个数组的首地址，类型不符；

警告3：左值为元素个数为3的数组指针，但是右值是指向含5个元素的数组第一个元素的首地址，类型不符；

警告3/4同2/3。

然后分析下打印出来的值：

由于左右值类型不兼容，从右值赋给左值之前先对右值进行了左值类型的强制转换。

然后就容易理解：

为什么p4+1的值是0xbffff2ba,而不是0xbffff2b6(未强制转换前); 强制转换后a指向整个数组的首地址，与&a相同；

为什么p5+1的值是0xbffff2b8,而不是0xbffff2ba;强制转换后&a由指向含5个元素的整个数组的首地址变为指向含3个元素的整个数组的首地址。

为什么p6+1的值是0xbffff2b8,而不是0xbffff2b6;这里是前面两种强制转换的综合结果。

后面雷同。

地址的强制类型转换

先看个实例

struct Test
{
    int Num;
    char *pcName;
    short sDate;
    char cha[2];
    short sBa[4];
}*p;

假设p的值为0x1000000。

p+0x1=?

(unsigned long)p+0x1=?

(unsigned int*)p+0x1=?

实质上是看编译器怎么处理指针变量和一个整数相加减。类似前面a+1和&a+1的区别。

指针变量与一个整数相加减并不是用指针变量里的地址直接加减这个整数。这个整数的单位不是byte而是元素的个数；

看强制类型转换博客中关于运算符的部分：http://www.cnblogs.com/kwseeker-bolgs/p/4488907.html

所以：

1. p+0x1=0x1000000+sizeof(Test)*0x1=0x1000014;

关于为什么这里的sizeof(Test)=20,后面详细介绍。

2. (unsigned long)p+0x1=?这里涉及强制类型转换，将struct类型转换为unsigned long,所以两者现在都是无符号长整型，直接相加：

(unsigned long)p+0x1=0x1000000+0x1=0x1000001;

3. (unsigned int*)p+0x1=?前者是无符号整形，后者也需要转换为无符号整形：

(unsigned int*)p+0x1=0x1000000+sizeof(unsigned int)*0x1=0x1000004;

4. (unsinged int)p+0x1=0x1000000+0x1=0x1000001;

这里要非常注意(unsinged int)与(unsinged int*)的区别，一个是按无符号整形数据处理，一个是按指针处理。

调试结果如下：这里的p=0x0;

技术分享

一个例题：

int main()
{
    int a[4]={1,2,3,4};
    int *ptr1=(int *)(&a+1);　　　　
    int *ptr2=(int *)((int)a+1);

    printf("%x, %x", ptr1[-1],*ptr2);　　//输出4,2000000
    return 0;
}

分析：ptr1[-1] 解析为*(ptr1-1)

技术分享

对于为什么会出现2000000，首先需要弄清系统大小端存储模式。

int checkSystem()
{
    union check
    {
        int i;    
        char ch;
    }
    c.i=1;
    return(c.ch==1);
}
//返回0为大端模式，返回1为小端模式

经过验证系统采用小端模式。所以*ptr2=0x02000000。

二维数组与二级指针

二维数组

二维数组char a[3][4]中a[i][j]元素的首地址是：a+i*sizeof(char)*4+j*sizeof(char),指针形式*(*(a+i)+j)。

一个陷阱题：

#include <stdio.h>
int main()
{
    int a[3][2]={(0,1),(2,3),(4,5)}; 
    int *p;
    p=a[0];
    printf("%d",p[0]);
}

读题时很容易忽略大括号里面嵌套的不是大括号而是小括号（即逗号表达式）。

上面的其实是int a[3][2]={1,3,5}={{1,3},{5,0},{0,0}};

int a[5][5];

int (*p)[4];

p=a;

问&p[4][2]-&a[4][2]的值是多少？

关键问题是int (*p)[4] 到 &p[4][2]是怎样的一个过程？

根据定义：p是一个指向包含4个元素的数组的指针。也就是说p+1表示的是指针p向后移动一个"包含4个int类型元素的数组"，这里1的单位是4*sizeof(int)。所以p[4]相对于p[0]来说是向后移动了4*(4*sizeof(int))。由于p被初始化为&a[0],那么& p[4][2]=&a[0][0]+4*4*sizeof(int)+2*sizeof(int)。（0x72-0x88bytes）

技术分享

数组参数与指针参数

1. 不能向函数以数组的形式传递一个数组，实参只能以指针的形式传递数组。但是函数定义的时候形参可以是数组形式。

C语言中，当一维数组作为函数参数的时候，编译器总是把它解析成一个指向其首元素首地址的指针。

#include <stdio.h>

void func(char a[10]){
	char c=a[3];
}
void func1(char *p){
	char c=p[3]; //或者 char c = *(p+3);
}
void func2(char a[]){
	char c=a[3];
}

int main(int argc, char const *argv[])
{
	char b[10]="abcdefg";
	//func(b[10]);		//此处的b[10]并不代表一个数组，而是一个越界的数组元素
	func(b);　　　　　　　　　//后面三个都是可以成功传值的
	func1(b);
	func2(b);

	return 0;
}

2.一级指针参数

1）能否把指针变量本身传递给一个函数

#include <stdio.h>

void func(char *p){
	char c=p[3]; //或者 char c = *(p+3);
}

int main(int argc, char const *argv[])
{
	char *p2="abcdefg";
	func(p2);　　//这样操作没有语法错误，但是此句所做的操作只是对拷贝做的，在main中没有意义

	return 0;
}

二维数组参数与二维指针参数

void fun(char a[3][4]); 还可写成 void fun(char a[][4]);

由上面的规则可以改写为

void fun(char (*p)[4]);　　//p指向a[3]的首地址

技术分享

函数指针与函数指针数组

下面转自http://patmusing.blog.163.com/blog/static/1358349602010182102157/

什么是函数指针?

函数指针指向的是特殊的数据类型，函数的类型是由其返回的数据类型和其参数列表共同决定的，而函数的名称则不是其类型的一部分。

一个具体函数的名字，如果后面不跟调用符号(即括号)，则该名字就是该函数的指针(注意：大部分情况下，可以这么认为，但这种说法并不很严格)。

函数指针的声明方法

// 定义函数指针pf

int (*pf)(const int&, const int&); (1)

上面的pf就是一个函数指针，指向所有返回类型为int，并带有两个const int&参数的函数。注意*pf两边的括号是必须的，否则上面的定义就变成了：

int *pf(const int&, const int&); (2)

而这声明了一个函数pf，其返回类型为int *，带有两个const int&参数。

用typedef定义函数指针类型

// 定义函数指针类型cmpFun

typedef int (*cmpFun)(const int&, const int&); (3)

或许这样写更容易理解 typedef int (*)(const int&, const int&) cmpFun;

这样，cmpFun就成了一种数据类型，可以用它来声明和定义形如(1)式中的pf那样的函数指针，比如：

cmpFun pf = 0;

cmpFun pf = someFunction;

举个例子来说明一下：

#include <iostream>
#include <string>
using namespace std;

// 定义函数指针pf
int (*pf)(const int&, const int&);   // int (*)(const int&, const int&) pf;

// 定义函数指针类型cmpFun
typedef int (*cmpFun)(const int&, const int&);

// 具体函数
int intCompare(const int& aInt, const int& bInt)
{
         if(aInt == bInt) return 0;
         if(aInt > bInt)
         {
                   return 1;
         }
         else
         {
                   return -1;
         }
}

int main(void)
{
         int aInt = 1;
         int bInt = 2;
         pf = intCompare;
         // pf = &stringCompare;              // 和上面一句是完全一样的
         // 使用pf
         if(pf(aInt, bInt) == 0)
         {
                   cout << "two integers are equal" << "." << endl;
         }
         else if(pf(aInt, bInt) > 0)
         {
                   cout << aInt << " is greater than " << bInt << "." << endl;
         }
         else
         {
                  cout << aInt << " is less than " << bInt << "." << endl;
         }

         cout << "------------------------" << endl;
         // 用函数指针类型cmpFun声明并初始化一个函数指针pf2
         cmpFun pf2 = intCompare;
         // 使用pf2
         if(pf2(aInt, bInt) == 0)
         {
                   cout << "two integers are equal" << "." << endl;
         }
         else if(pf(aInt, bInt) > 0)
         {
                   cout << aInt << " is greater than " << bInt << "." << endl;
         }
         else
         {
                   cout << aInt << " is less than " << bInt << "." << endl;
         }

         return 0;
}

函数指针作为参数

函数指针可以作为一个函数的参数，如下两种办法可以做到这一点：

(a) int plusFun(int&, int&, int (const int&, const int&));

(b) int plusFun(int&, int(*)(const int&, const int&));

以上两个方式做到的是类似的事情：(a)中的plusFun函数的第三个参数就是一个函数指针， (b)中的第二个参数也是一个函数指针。下面我们分别定义前面声明的两个plusFun函数。

(a)中的plusFun定义如下：

//函数指针作为参数：错误的做法

//int plusFun(int& aInt, int& bInt, int paf(const int& cInt, const int& dInt))

//{

// return aInt + bInt + paf(cInt, dInt);

//}

//函数指针作为参数：正确的做法

int plusFun(int& aInt, int& bInt, int paf(const int &, const int &))

{

int cInt = 2;

int dInt = 1;

return aInt + bInt + paf(cInt, dInt);

}

调用plusFun的代码：

…

pf = intCompare;

…

// 函数指针作为参数

int aaInt = 3;

int bbInt = 4;

cout << plusFun(aaInt, bbInt, pf) << endl;

(b)中的plusFun定义如下：

//函数指针作为参数：错误的做法

//int plusFun(int& aInt, int(*paf2)(const int& bInt, const int& cInt))

//{

// return aInt + paf2(bInt, cInt);

//}

//函数指针作为参数：正确的做法

int plusFun(int& aInt, int(*paf2)(const int&, const int&))

{

int bInt = 1;

int cInt = 2;

return aInt + paf2(bInt, cInt);

}

调用plusFun的代码：

…

cmpFun pf2 = intCompare;

…

// 函数指针作为参数

int aaInt = 3;

cout << plusFun(aaInt, pf2) << endl;

函数指针作为返回值

一个函数的返回值可以是一个函数指针，这个声明形式写起来有点麻烦：

// 函数指针作为返回值

int (*retFunPointer(int))(const int&, const int&);

上面的声明的含义：

a) retFunPointer是一个函数，该函数有一个int类型的参数；

b) retFunPointer返回值是一个函数指针，它指向的是带有两个const int&类型参数，且返回类型为int的函数。

retFunPointer的定义：

// 函数指针为返回值

int (*retFunPointer(int aInt))(const int&, const int&)

{

cout << aInt << endl;

// pf已经在前面定义过了

return pf;

}

调用代码示例：

// 函数指针作为返回值，retFunPointer返回一个cmpFun类型的函数指针

cmpFun pf3 = retFunPointer(aaInt);

int result = pf3(aaInt, bbInt);

cout << result << endl;

包含上面所有情况的完整代码

#include <iostream>
#include <string>
using namespace std;

// 定义函数指针pf
int (*pf)(const int&, const int&);

// 定义函数指针类型cmpFun
typedef int (*cmpFun)(const int&, const int&);

// 函数指针作为参数
int plusFun(int&, int(const int&, const int&));
int plusFun(int&, int(*)(const int&, const int&));

// 函数指针作为返回值
int (*retFunPointer(int))(const int&, const int&);

// 具体函数
int intCompare(const int& aInt, const int& bInt)
{
         if(aInt == bInt) return 0;
         if(aInt > bInt)
         {
                   return 1;
         }
         else
         {
                   return -1;
         }
}

//函数指针作为参数：错误的做法
//int plusFun(int& aInt, int& bInt, int paf(const int& cInt, const int& dInt))
//{
//
//       return aInt + bInt + paf(cInt, dInt);
//}

//函数指针作为参数：正确的做法
int plusFun(int& aInt, int& bInt, int paf(const int &, const int &))
{
         int cInt = 2;
         int dInt = 1;
         return aInt + bInt + paf(cInt, dInt);
}

//函数指针作为参数：错误的做法
//int plusFun(int& aInt, int(*paf2)(const int& bInt, const int& cInt))
//{
//       return aInt + paf2(bInt, cInt);
//}

//函数指针作为参数：正确的做法
int plusFun(int& aInt, int(*paf2)(const int&, const int&))
{
         int bInt = 1;
         int cInt = 2;
         return aInt + paf2(bInt, cInt);
}

// 函数指针为返回值
int (*retFunPointer(int aInt))(const int&, const int&)
{
         cout << aInt << endl;
         // pf已经在前面定义过了
         return pf;
}

int main(void)
{
         int aInt = 1;
         int bInt = 2;
         pf = intCompare;
         // pf = &stringCompare;              // 和上面一句是完全一样的
         // 使用pf
         if(pf(aInt, bInt) == 0)
         {
                   cout << "two integers are equal" << "." << endl;
         }
         else if(pf(aInt, bInt) > 0)
         {
                   cout << aInt << " is greater than " << bInt << "." << endl;
         }
         else
         {
                   cout << aInt << " is less than " << bInt << "." << endl;
         }

         cout << "------------------------" << endl;
         // 用函数指针类型cmpFun声明并初始化一个函数指针pf2
         cmpFun pf2 = intCompare;
         // 使用pf2
         if(pf2(aInt, bInt) == 0)
         {
                   cout << "two integers are equal" << "." << endl;
         }
         else if(pf(aInt, bInt) > 0)
         {
                   cout << aInt << " is greater than " << bInt << "." << endl;
         }
         else
         {
                   cout << aInt << " is less than " << bInt << "." << endl;
         }
         cout << "------------------------" << endl;

         // 函数指针作为参数
         int aaInt = 3;
         int bbInt = 4;
         cout << plusFun(aaInt, bbInt, pf) << endl;
         cout << plusFun(aaInt, pf2) << endl;
         cout << "------------------------" << endl;

         // 函数指针作为返回值，retFunPointer返回一个cmpFun类型的函数指针
         cmpFun pf3 = retFunPointer(aaInt);
         int result = pf3(aaInt, bbInt);
         cout << result << endl;

         return 0;
}

原文：http://www.cnblogs.com/kwseeker-bolgs/p/4593119.html

内容总结

以上是互联网集市为您收集整理的C语言指针与数组的定义与声明易错分析全部内容，希望文章能够帮你解决C语言指针与数组的定义与声明易错分析所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1180054.html

来源：【匿名】

【上一篇】在C语言中，double、long、unsigned、int、char类型数据所占字节数【下一篇】C语言MD5的源码实例详解

更多 ►

【C语言指针与数组的定义与声明易错分析】教程文章相关的互联网学习教程文章

c语言之使用指针将数组进行反转【代码】【图】

#include<stdio.h> #include<iostream>void reverse(int* a, int length) {int* p, temp, * i, * j, m;m = (length - 1) / 2;//取得中间的下标i = a;//i指向数组的首元素j = a + length - 1;//j指向数组的尾元素p = a + m;//p指向数组中间的元素for(; i < p; i++,j--){//依次交换首位元素的值temp = *i;*i = *j;*j = temp;} } void printArr(int arr[],int length) {for (int i = 0; i < length; i++){printf("%d ", arr[i]);}putc...

C语言博客作业--字符数组【代码】【图】

一、PTA实验作业题目1：7-1 字符串转换成十进制整数1. 本题PTA提交列表2. 设计思路（伪代码或流程图）int i,j;char a[80],b[80];int flag1=0,flag2=0;long number;其中flag2为是否有负号的判断标志，flag1为输出结果正负的判断标志输入以’#‘结束的字符串a[] 遍历数组a[i], 滤去非16进制数如果a[i]==‘-‘&&flag2==0 flag1=1;如果为16进制数，b[j]=a[i] ; flag2=1 ; j++; 结束符b[j]=‘\0‘; 将新字符串逐个转换,存放在n...

C语言指针与数组【代码】

前言：指针！菜鸟的终点，高手的起点。漫谈一些进阶之路上的趣事；记录一些语言本身的特性以及思想，没有STL，也没有API！0x01: 字符串？　　众所周知C中是没有类似 string 类型的(别给我说<string.h>)，代之的是字符数组；通常我们使用以 ‘\0‘ 结尾的字符数组来表示字符串char ch1[]={‘a‘,‘b‘,‘c‘}; char ch2[]={‘x‘,‘y‘,‘z‘,‘\0‘}; char ch3[]="123";printf("ch1=%s,\nch2=%s,\nch3=%s,\n",ch1,ch2,ch3);/*输出：...

1026: C语言程序设计教程（第三版）课后习题7.4数组排序【代码】

1026: C语言程序设计教程（第三版）课后习题7.4题目描述已有一个已排好的9个元素的数组，今输入一个数要求按原来排序的规律将它插入数组中。输入第一行，原始数列。第二行，需要插入的数字。输出排序后的数列样例输入1 7 8 17 23 24 59 62 101 50样例输出1 7 8 17 23 24 50 59 62 101 提示来源#include<stdio.h>intmain(){ inta[10],i,t; for(i=0; i<10; i++)scanf("%d",&a[i]); for(i=9; i!=0; i--)if(a[i]<a[i-1])t=a...

【C语言】12-指向一维数组元素的指针【代码】【图】

一、用指针指向一维数组的元素 1 // 定义一个int类型的数组2 int a[2];3 4 // 定义一个int类型的指针5 int *p;6 7 // 让指针指向数组的第0个元素8 p = &a[0];9 10 // 修改所指向元素的值 11 *p = 10; 12 13 // 打印第一个元素的值 14 printf("a[0] = %d", a[0]);输出结果：，说明已经通过指针间接修改了数组元素的值，跟指向一个普通int类型变量是一样的。由于数组名代表着数组的首地址，即a == &a[0]，因此第8行代码等价于：// ...

C语言指针与数组的定义与声明易错分析【代码】【图】

部分摘自《C语言深度解剖》1.定义为数组，声明为指针在文件1中定义：char a[100];在文件2中声明：extern char *a;　　//这样是错误的这里的extern告诉编译器a这个名字已经在别的文件中被定义了，下面的代码使用的a是在别的文件中定义的。编译器是按文件分别编译的，当a被声明为char* a时，编译器理所当然的认为a是一个指针变量，在32位系统下占用4个byte,这4个byte存放的是地址，地址指向的空间存储的是char类型数据。程序会返回SI...

C 语言入门---第六章 C语言数组

数组就是一些列具有相同类型的数据的集合，这些数据在内存中一次挨着存放，彼此之间没有缝隙。我们可以将二维数组看作一个Excel表格，有行有列，length1 表示行数，length2 表示列数，要在二维数组中定位某个元素，必须同时指明行和列。　　二维数组在概念上是二维的，但在内存中是连续存放的，换句话说，二维数组的各个元素是相互挨着的，彼此之间没有缝隙。在线性内存中存放二维数组有两种方式：　　1. 按行排列，放完一行之后再...

C语言指针和数组【代码】【图】

#include <stdio.h> int main() {/*********************************************** 指针和数组：* 定义数组：数组名就是数组第一个元素的地址* int ages[5];* int *p;* p = ages;* 访问数组元素的方法：* 1、数组名[下标] ages[i]* 2、指针变量名[下标] p[i]* 3、*(p + i)** 指针变量+1，地址值究竟加多少，取决于指针的类型* int * 4* char * 1* double * 8**********************...

C语言算法设计一个算法，将数组m个元素循环右移。要求算法空间复杂度为O(1)【代码】

题目如题：数组是一个常规一维数组，直接放代码，代码讲解见注解#include<stdio.h> void swap(int a[],int i,int j) {a[i]=a[i]+a[j]-(a[j]=a[i]); } void insert(int a[],int i,int n)//插入算法，每次把第i个数放到这个数组的最后面{int key=a[i];//插入算法的核心思想和插入排序当中是一样的，设定一个key，让key插入到最后面while(i<n){a[i]=a[i+1];++i;if(i+1==n)//当i处于数组最后一位的时候，停止循环break;}a[i]=key;//在数...

c语言：通过指针变量输出整型数组a的10个元素

通过指针变量输出整型数组a的10个元素。解：程序：#include<stdio.h>int main(){int i, a[10], *p=a;printf("please enter 10 integer numbers:");for (i = 0; i < 10; i++){scanf("%d", p++);}p = a;for (i = 0; i < 10; i++, p++){printf("%3d", *p);}printf("\n");return 0;}结果：please enter 10 integer numbers:0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9请按任意键继续. . . 本文出自 “岩枭” 博客，请务必保留...

C语言博客作业--字符数组【代码】【图】

一、PTA实验作业题目1：7-5 统计大写辅音字母1. 本题PTA提交列表2. 设计思路（用代码表示扣分）3.代码截图4.本题调试过程碰到问题及PTA提交列表情况说明。题目2：1. 本题PTA提交列表2. 设计思路（用代码表示扣分）3.代码截图4.本题调试过程碰到问题及PTA提交列表情况说明。题目3：1. 本题PTA提交列表2. 设计思路（用代码表示扣分）3.代码截图4.本题调试过程碰到问题及PTA提交列表情况说明。二、截图本周题目集的PTA最后排名。三、同...

c语言实现动态指针数组Dynamic arrays

c语言实现动态数组。基本原理：事先准备好一个固定长度的数组。如果长度不够的时候，realloc一块区域。另外：在数组元素减少的情况下，需要缩减数组长度。主要接口：cp_bool DyArrayAppend(DyArray* pArr, void* pData)//加数据到数组末尾 cp_bool DyArrayExpand(DyArray* pArr, cp_int32 nNeed)//扩展数组 cp_bool DyArrayDelete(DyArray* pArr, cp_int32 nIndex)//删除元素by index cp_bool DyArrayShrink(DyArray* pArr)//缩减数...

C语言第四讲:一维数组,字符数组

数组: 定义: 数据类型数组名[数组元素个数] = {值1,值2,....} 本质:快速定义多个相同数据类型的变量数组的缺点:定义出来的是相同数据类型的变量.如:int c[5] = {0};//在给定数组元素个数的时候,可以按照该模式,全部赋初值为零 int a[] = {4, 5, 6};//在没有给定数组元素个数的时候,可以按照该模式,此时,一定要写清楚所有的初值.数组元素的访问: 通过数组名加下标来访问的如:a[1],切记下标从零开始...

【C语言】（数组方式）求n名同学的平均成绩【代码】

原理就不说了代码：#include <stdio.h> int main() {float score[5], sum = 0;int i;printf("请输入5名童鞋的成绩：\n");for (i = 0; i < 5; i = i + 1)scanf_s("%f", &score[i]);for (i = 0; i < 5; i = i + 1)sum = sum + score[i];printf("平均成绩为：%.1f\n", sum / 5);} 原文：https://www.cnblogs.com/HGNET/p/11919525.html

c语言中输入数组元素的值【代码】【图】

1、一维数组#include <stdio.h>#define NUMBER 6int main(void) {int i;int v[NUMBER];for (i = 0; i < NUMBER; i++){printf("v[%d] = ", i); scanf("%d", &v[i]);}for (i = 0; i < NUMBER; i++){printf("v[%d]: %d \n", i, v[i]);}return0; } 原文：https://www.cnblogs.com/liujiaxin2018/p/14587337.html

首页 / C语言 / C语言指针与数组的定义与声明易错分析

C语言指针与数组的定义与声明易错分析

内容导读

内容图文

内容总结

内容备注

内容手机端

【C语言指针与数组的定义与声明易错分析】教程文章相关的互联网学习教程文章

c语言之使用指针将数组进行反转【代码】【图】

C语言博客作业--字符数组【代码】【图】

C语言指针与数组【代码】

1026: C语言程序设计教程（第三版）课后习题7.4数组排序【代码】

【C语言】12-指向一维数组元素的指针【代码】【图】

C语言指针与数组的定义与声明易错分析【代码】【图】

C 语言入门---第六章 C语言数组

C语言指针和数组【代码】【图】

C语言算法设计一个算法，将数组m个元素循环右移。要求算法空间复杂度为O(1)【代码】

c语言：通过指针变量输出整型数组a的10个元素

C语言博客作业--字符数组【代码】【图】

c语言实现动态指针数组Dynamic arrays

C语言第四讲:一维数组,字符数组

【C语言】（数组方式）求n名同学的平均成绩【代码】

c语言中输入数组元素的值【代码】【图】

C语言 - 相关标签

数组 - 相关标签

指针 - 相关标签

C语言 - 技术教程分类

C语言 - 最新教程

C语言 - 最热教程