C语言-基础语法（五）：数组和字符串

已于 2022-09-16 08:34:33 修改
阅读量336 收藏 2
点赞数 1
分类专栏： # C/基础语法 文章标签： c语言 c++ 数组 字符串
于 2021-04-29 21:52:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013250861/article/details/116271549
版权

在程序设计中，为了方便处理数据把具有相同类型的若干变量按有序形式组织起来——称为数组。

数组就是在内存中连续的相同类型的变量空间。

  • 同一个数组所有的成员都是相同的数据类型；
  • 同时所有的成员在内存中的地址是连续的；
  • 数组中的每一个元素都是一个变量；

在这里插入图片描述
数组属于构造数据类型：

  • 一个数组可以分解为多个数组元素：这些数组元素可以是基本数据类型或构造类型。
    int a[10];  
struct Stu boy[10];
  • 按数组元素类型的不同，数组可分为：数值数组、字符数组、指针数组、结构数组等类别。
    int a[10];
char s[10];
char *p[10];

通常情况下，数组元素下标的个数也称为维数，根据维数的不同，可将数组分为一维数组、二维数组、三维数组、四维数组等。通常情况下，我们将二维及以上的数组称为多维数组。

一、一维数组

1、 一维数组的定义和使用

  • 数组名字符合标识符的书写规定(数字、英文字母、下划线)
  • 数组名不能与其它变量名相同，同一作用域内是唯一的
  • 方括号[]中常量表达式表示数组元素的个数
    int a[3]表示数组a有3个元素
其下标从0开始计算，因此3个元素分别为a[0],a[1],a[2]
  • 定义数组时[]内最好是常量，使用数组时[]内即可是常量，也可以是变量
#include <stdio.h>

int main()
{
	int a[10];//定义了一个数组，名字叫a，有10个成员，每个成员都是int类型
	//a[0]…… a[9]，没有a[10]
	//没有a这个变量，a是数组的名字，但不是变量名，它是常量
	a[0] = 0;
	//……
	a[9] = 9;

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		a[i] = i; //给数组赋值
	}

	//遍历数组，并输出每个成员的值
	for (i = 0; i < 10; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

	return 0;
}

int main()
{
        // 数组名和变量名定义方法一样
        //符号与[]结合代表这个是一个数组
        //数组中的元素的个数由[]里面的数值决定
        //每个元素的类型,数组名前面的类型决定
        //定义数组时,[]里面的值不能为变量,只能为常量
        //使用时,[]里面的值可以为常量也可以是变量
        //数值数组不能整体操作
        //数组的每一个元素都是变量,可以被改变赋值
        int  n = 10;
        int  num[10];
        //num[0] = 100;
        //printf("%d\n",num[0]);
        for (int i = 0; i < 10; i++)
        {
               printf("%d\n", num[i]);
               
        }
        system("pause");
        return 0;
}

2、一维数组的初始化

在定义数组的同时进行赋值，称为初始化。全局数组若不初始化，编译器将其初始化为零。局部数组若不初始化，内容为随机值。

	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//定义一个数组，同时初始化所有成员变量
	int a[10] = { 1, 2, 3 };//初始化前三个成员，后面所有元素都设置为0
	int a[10] = { 0 };//所有的成员都设置为0
	
	 //[]中不定义元素个数，定义时必须初始化
	 int a[] = { 1, 2, 3, 4, 5 };//定义了一个数组，有5个成员

//数组的初始化
int main()
{
        
        //int  num[10] = {1,2,3,4,5,6,7,8,9,10};
        //如果数组只初始化部分元素,其他元素被初始化为0
        //int  num[10] = { 1,2 };
        //int num[10] = { 0 };//将数组所有元素初始化为0
        //int  num[10] = {[5]=5};
        //int num[]; err  定义时没有告知有几个元素
        int  num[] = { 1,2,3 };//如果定义时,[]中没有值,这个数组的元素个数由{}里面的元素个数决定
        for (int i = 0; i < 10; i++)
        {
               printf("%d ", num[i]);
        }
        printf("\n");
        system("pause");
        return 0;
}

3、数组名

一般数据在内存的地址：
在这里插入图片描述
数组名是一个地址的常量，代表数组中首元素的地址。

int a[10]

  • 数组名a ,等价于第0个元素的地址(首元素地址)
  • 数组名是常量,不能被赋值
  • &a[0] 第0个元素的地址
  • &a 整个数组地址

在这里插入图片描述

int main()
{
        int  a[5];
        printf("%u\n",&a[0]);
        printf("%u\n", a);
        printf("%u\n", &a);
        printf("%u\n", &a[0]+1);
        printf("%u\n", a+1);
        printf("%u\n", &a+1);
        system("pause");
        return 0;
}

#include <stdio.h>

int main()
{
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//定义一个数组，同时初始化所有成员变量

	printf("a = %p\n", a);
	printf("&a[0] = %p\n", &a[0]);

	int n = sizeof(a); //数组占用内存的大小，10个int类型，10 * 4  = 40
	int n0 = sizeof(a[0]);//数组第0个元素占用内存大小，第0个元素为int，4

	int i = 0;
	for (i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

	return 0;
}

4、数组的大小

//数组的大小
int main()
{
        //num是数组名,代表这个数组
        int  num[10] = { 1,2,3,4,5,6,7,8,9,10 };
        printf("%d\n",sizeof(int [10]));
        printf("%d\n", sizeof(num));
        //求数组元素个数
        int n = sizeof(num) / sizeof(num[0]);
        printf("n=%d\n",n);
        for (int i = 0; i < sizeof(num)/sizeof(num[0]); i++)
        {
               printf("%d ", num[i]);
        }
        system("pause");
        return 0;
}

4、一维数组强化训练

4.1 一维数组的最值

#include <stdio.h>

int main()
{
	int a[] = {  1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量

	int i = 0;
	int max = a[0];
	for (i = 1; i < sizeof(a) / sizeof(a[0]); i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
	}
	printf("数组中最大值为：%d\n", max);

	return 0;
}

4.2 一维数组的逆置

#include <stdio.h>

int main()
{
	int a[] = {  1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量

	int i = 0;
	int j = sizeof(a) / sizeof(a[0]) -1;
	int tmp;

	while (i < j)
	{
		tmp = a[i];
		a[i] = a[j];
		a[j] = tmp;
		i++;
		j--;
	}

	for (i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

	return 0;
}

4.3 冒泡法排序（有2层for循环）

在这里插入图片描述

第一层for循环

  • 第一次循环（通过第2层for循环依次比较相邻的元素，，把大的放到后面）找出该数组最大值；
  • 第二次循环（通过第2层for循环依次比较相邻的元素，，把大的放到后面）找出该数组第2大数值；
  • 第三次循环（通过第2层for循环依次比较相邻的元素，，把大的放到后面）找出该数组第3大数值；
  • …
  • 第n-1轮循环（通过第2层for循环依次比较相邻的元素，，把大的放到后面）找出该数组倒数第2大数值；
//数组的排序 - 冒泡排序
int main()
{
        int   a[5] = {2,5,6,3,-1};
        int n = sizeof(a) / sizeof(a[0]);
        for (int i = 0; i < n - 1; i++)//比较的轮数
        {
               //因为每次比较的次数都要减1,刚好i每次加1,所以每一轮 比较的次数是n-1-i
               for (int j = 0; j < n-1-i;j++ )	//每一轮需要比较的次数【内循环的目的是比较相邻的元素，把大的放到后面】
               {
                       if (a[j] > a[j + 1])//如果前面的元素比后面的元素大,则交换位置
                       {
                              int tmp = a[j + 1];
                              a[j + 1] = a[j];
                              a[j] = tmp;
                       }
               }
        }
        for (int i = 0; i < n; i++)
        {
               printf("%d ",a[i]);
        }
        printf("\n");
        system("pause");
        return 0;
}

二、二维数组

1、二维数组的定义和使用

二维数组就是有多个一维数组。

二维数组定义的一般形式是：类型说明符 数组名[常量表达式1][常量表达式2]。

  • 常量表达式1表示第一维下标的长度，
  • 常量表达式2 表示第二维下标的长度。

int a[3][4];

  • 命名规则同一维数组
  • 定义了一个三行四列的数组，数组名为a其元素类型为整型，该数组的元素个数为3×4个，即：
    在这里插入图片描述

二维数组a是按行进行存放的，先存放a[0]行，再存放a[1]行、a[2]行，并且每行有四个元素，也是依次存放的。

  • 二维数组在概念上是二维的：其下标在两个方向上变化，对其访问一般需要两个下标。
  • 在内存中并不存在二维数组，二维数组实际的硬件存储器是连续编址的，也就是说内存中只有一维数组，即放完一行之后顺次放入第二行，和一维数组存放方式是一样的。
#include <stdio.h>

int main()
{
	//定义了一个二维数组，名字叫a
	//由3个一维数组组成，这个一维数组是int [4]
	//这3个一维数组的数组名分别为a[0],a[1],a[2]
	int a[3][4];

	a[0][0] = 0;
	//……
	a[2][3] = 12;

	//给数组每个元素赋值
	int i = 0;
	int j = 0;
	int num = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			a[i][j] = num++;
		}
	}

	//遍历数组，并输出每个成员的值
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			printf("%d, ", a[i][j]);
		}
		printf("\n");
	}

	return 0;
}

2、二维数组的初始化

//分段赋值 	int a[3][4] = {{ 1, 2, 3, 4 },{ 5, 6, 7, 8, },{ 9, 10, 11, 12 }};
	int a[3][4] = 
	{ 
		{ 1, 2, 3, 4 },
		{ 5, 6, 7, 8, },
		{ 9, 10, 11, 12 }
	};

	//连续赋值
	int a[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12  };

	//可以只给部分元素赋初值，未初始化则为0
	int a[3][4] = { 1, 2, 3, 4  };

	//所有的成员都设置为0
	int a[3][4] = {0};

	//[]中不定义元素个数，定义时必须初始化
	int a[][4] = { 1, 2, 3, 4, 5, 6, 7, 8};

3、二维数组的数组名

在这里插入图片描述
在这里插入图片描述

数组名是一个地址的常量，代表数组中首元素的地址。

#include <stdio.h>

int main()
{
	//定义了一个二维数组，名字叫a
	//二维数组是本质上还是一维数组，此一维数组有3个元素
//每个元素又是一个一维数组int[4]
	int a[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12  };

	//数组名为数组首元素地址，二维数组的第0个元素为一维数组
	//第0个一维数组的数组名为a[0]
	printf("a = %p\n", a);
	printf("a[0] = %p\n", a[0]);
	
	//测二维数组所占内存空间，有3个一维数组，每个一维数组的空间为4*4
	//sizeof(a) = 3 * 4 * 4 = 48
	printf("sizeof(a) = %d\n", sizeof(a));

	//测第0个元素所占内存空间，a[0]为第0个一维数组int[4]的数组名，4*4=16
	printf("sizeof(a[0]) = %d\n", sizeof(a[0]) );

	//测第0行0列元素所占内存空间，第0行0列元素为一个int类型，4字节
	printf("sizeof(a[0][0]) = %d\n", sizeof(a[0][0]));

	//求二维数组行数
	printf("i = %d\n", sizeof(a) / sizeof(a[0]));

	// 求二维数组列数
	printf("j = %d\n", sizeof(a[0]) / sizeof(a[0][0]));

	//求二维数组行*列总数
	printf("n = %d\n", sizeof(a) / sizeof(a[0][0]));

	return 0;
}

4、二维数组强化训练

在这里插入图片描述

#include <stdio.h>

int main()
{
	//二维数组：  五行、三列
	//行代表人：  老大到老五
	//列代表科目：语、数、外
	float a[5][3] = { { 80, 75, 56 }, { 59, 65, 71 }, { 59, 63, 70 }, { 85, 45, 90 }, { 76, 77, 45 } };

	int i, j, person_low[3] = { 0 };
	float s = 0, lesson_aver[3] = { 0 };

	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			s = s + a[j][i];
			if (a[j][i] < 60)
			{
				person_low[i]++;
			}
		}

		lesson_aver[i] = s / 5;
		s = 0;
	}

	printf("各科的平均成绩:\n");
	for (i = 0; i < 3; i++)
	{
		printf("%.2f\n", lesson_aver[i]);
	}
		
	printf("各科不及格的人数:\n");
	for (i = 0; i < 3; i++)
	{
		printf("%d\n", person_low[i]);
	}
		
	return 0;
}

三、字符数组与字符串

1、字符数组与字符串区别

  • C语言中没有字符串这种数据类型，可以通过char的数组来替代；
  • 字符串一定是一个char的数组，但char的数组未必是字符串；
  • 数字0(和字符‘\0’等价)结尾的char数组就是一个字符串，但如果char数组没有以数字0结尾，那么就不是一个字符串，只是普通字符数组，所以字符串是一种特殊的char的数组。
#include <stdio.h>

int main()
{
	char c1[] = { 'c', ' ', 'p', 'r', 'o', 'g' }; //普通字符数组
	printf("c1 = %s\n", c1); //乱码，因为没有’\0’结束符

	//以‘\0’(‘\0’就是数字0)结尾的字符数组是字符串
	char c2[] = { 'c', ' ', 'p', 'r', 'o', 'g', '\0'}; 
	printf("c2 = %s\n", c2);

	//字符串处理以‘\0’(数字0)作为结束符，后面的'h', 'l', 'l', 'e', 'o'不会输出
	char c3[] = { 'c', ' ', 'p', 'r', 'o', 'g', '\0', 'h', 'l', 'l', 'e', 'o', '\0'};
	printf("c3 = %s\n", c3);

	return 0;
}

int main()
{
        //"hello"
        //字符数组
        //字符串就是字符数组中有\0字符的数组
        //因为有\0字符的字符数组,操作起来方便
        //char  a[5] = {'a','b','c','d','e'};普通的字符数组
        //char  a[5] = {'a','b','c','d','\0'};//字符数组中含有\0字符的,它也是字符串
        //char  a[5] = "abcd";//定义了一个字符数组,存的是abcd\0
        //char  a[] = "world";//
        //char  a[100] = "abcd";//定义了一个字符数组,有100个元素
        //char  a[100] = "\0";//将数组的第0个元素填\0,其他元素就是\0
        char  a[100] = { 0 };//将一个字符数组清0
        /*for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
        {
               printf("%c",a[i]);
        }*/
        printf("%s\n",a);
        printf("\n");
        printf("%s\n","hello");
        system("pause");
        return 0;
}

2、字符串的初始化

#include <stdio.h>

// C语言没有字符串类型，通过字符数组模拟
// C语言字符串，以字符‘\0’, 数字0
int main()
{
	//不指定长度, 没有0结束符，有多少个元素就有多长
	char buf[] = { 'a', 'b', 'c' };
	printf("buf = %s\n", buf);	//乱码

	//指定长度，后面没有赋值的元素，自动补0
	char buf2[100] = { 'a', 'b', 'c' };

	char buf[1000]={“hello”};
	printf("buf2 = %s\n", buf2);

	//所有元素赋值为0
	char buf3[100] = { 0 };

	//char buf4[2] = { '1', '2', '3' };//数组越界

	char buf5[50] = { '1', 'a', 'b', '0', '7' };
	printf("buf5 = %s\n", buf5);

	char buf6[50] = { '1', 'a', 'b', 0, '7' };
	printf("buf6 = %s\n", buf6);

	char buf7[50] = { '1', 'a', 'b', '\0', '7' };
	printf("buf7 = %s\n", buf7);

	//使用字符串初始化，编译器自动在后面补0，常用
	char buf8[] = "agjdslgjlsdjg";

	//'\0'后面最好不要连着数字，有可能几个数字连起来刚好是一个转义字符
	//'\ddd'八进制字义字符，'\xdd'十六进制转移字符
	// \012相当于\n
	char str[] = "\012abc";
	printf("str == %s\n", str);

	return 0;
}

输出结果：

buf = abc烫烫天伿岟?
buf_2 = hello
buf5 = 1ab07
buf6 = 1ab
buf7 = 1ab
str ==
abc

3、字符串的输入输出

由于字符串采用了’\0’标志，字符串的输入输出将变得简单方便。

3.1 scanf()：从键盘读取字符串

scanf 缺点: 遇到空格就会提前结束读取, 如果存放读取字符的空间不足,继续向后存放,会造成内存污染
在这里插入图片描述

#include <stdio.h>

int main()
{
	char str[10];
   
	printf("input string1 : \n");
	scanf("%s", str);//scanf(“%s”,str)默认以空格分隔
	printf("output:%s\n", str);

	return 0;
}

3.2 gets()：从键盘读取字符串

gets是一个库函数,从键盘读取字符串。

char *gets(char *s);

  • 功能：
    • 从标准输入读入字符，并保存到s指定的内存空间，直到出现换行符或读到文件结尾为止。
  • 参数：
    • s：字符串首地址
  • 返回值：
    • 成功：读入的字符串
    • 失败：NULL

gets(str)与scanf(“%s”,str)的区别：

  • gets(str)允许输入的字符串含有空格
  • scanf(“%s”,str)不允许含有空格

注意：由于scanf()和gets()无法知道字符串s大小，必须遇到换行符或读到文件结尾为止才接收输入，因此容易导致字符数组越界(缓冲区溢出)的情况。

int main()
{
        //gets遇到\n结束.,但是遇到空格不结束读取空格
        //gets也会造成内存污染
        char  num[5] = "";
        gets(num);//()里面的参数要的是存放读取字符串的地址
        printf("num=%s\n",num);
        system("pause");
        return 0;
}

3.3 fgets()： 从键盘读取一个字符串

char *fgets(char *s, int size, FILE *stream);

  • 功能：
    • 从stream指定的文件内读入字符，保存到s所指定的内存空间，直到出现换行字符、读到文件结尾或是已读了size - 1个字符为止，最后会自动加上字符 ‘\0’ 作为字符串结束。
  • 参数：
    • s：字符串
    • size：指定最大读取字符串的长度（size - 1）
    • stream：文件指针，如果读键盘输入的字符串，固定写为stdin
  • 返回值：
    • 成功：成功读取的字符串
    • 读到文件尾或出错： NULL

fgets()在读取一个用户通过键盘输入的字符串的时候，同时把用户输入的回车也做为字符串的一部分。通过scanf和gets输入一个字符串的时候，不包含结尾的“\n”，但通过fgets结尾多了“\n”。fgets()函数是安全的，不存在缓冲区溢出的问题。

char num[128];
fgets(   num,   sizeof(num)    ,stdin  );//fgtes从stdin(标准输入-键盘)读取字符串到num数组中,最大可以读sizeof(num)-1个字符

int main()
{
        //fgets会把回车键\n读取
        char buf[1024] = "";
        fgets(buf,sizeof(buf),stdin);//hello\n
        printf("%s\n",buf);
        system("pause");
        return 0;
}

fgets 相对于scanf 和 gets不会污染内存,(安全),但是fgets会将\n读取

3.4 strlen()：求字符数组字符个数

size_t strlen(const char *s);

  • 功能：
    • 计算指定指定字符串s的长度，不包含字符串结束符‘\0’
  • 参数：
    • s：字符串（字符数组）首地址
    • 返回值：字符串s的长度，size_t为unsigned int类型
int main()
{
        char buf[128] = "helloA";//buf[5]=0;
        //需要找到最后一个字符的下标
        //求的是字符数组有效字符的个数
        int i = 0;
        /*while (buf[i] != '\0')
        {
               i++;
        }
        printf("i=%d\n",i);*/
        i = strlen(buf);//strlen()测字符数组有效字符的个数
        printf("i=%d\n", i);
        buf[i - 1] = '\0';
        printf("%s\n",buf);
        system("pause");
        return 0;
}

输出结果：

i=6
hello

3.5 puts()

int puts(const char *s);

  • 功能：
    • 标准设备输出s字符串，在输出完成后自动输出一个’\n’。
  • 参数：
    • s：字符串首地址
  • 返回值：
    • 成功：非负数
    • 失败：-1
#include <stdio.h>

int main()
{
	printf("hello world");
	puts("hello world");

	return 0;
}

3.6 fputs()

int fputs(const char * str, FILE * stream);

  • 功能：
    • 将str所指定的字符串写入到stream指定的文件中， 字符串结束符 ‘\0’ 不写入文件。
  • 参数：
    • str：字符串
    • stream：文件指针，如果把字符串输出到屏幕，固定写为stdout
  • 返回值：
    • 成功：0
    • 失败：-1

fputs()是puts()的文件操作版本，但fputs()不会自动输出一个’\n’。

	printf("hello world");
	puts("hello world");
	fputs("hello world", stdout);

int main()
{
        char buf[1024] = "helloworld";
        //printf("%s\n",buf);
        //puts(buf);//数组首元素地址,有换行
        fputs(buf,stdout);//第一个参数,数组首元素地址,stdout标准输出(屏幕)
        system("pause");
        return 0;
}

4、字符串强化训练

字符串追加

#include<stdio.h>
#include<stdlib.h>

int main()
{
	char str1[] = "abcdef";
	char str2[] = "123456";
	char dst[100];

	int i = 0;
	while (str1[i] != 0)
	{
		dst[i] = str1[i];
		i++;
	}

	int j = 0;
	while (str2[j] != 0)
	{
		dst[i + j] = str2[j];
		j++;
	}
	dst[i + j] = 0; //字符串结束符

	printf("dst = %s\n", dst);

	return 0;
}

输出结果：

dst = abcdef123456
u013250861
关注
专栏目录
C++基础语法五-数组
LMstudio702c的博客
08-13 259
C++基础语法五-数组1、元组个数2、初始化3、默认值问题：4、二维数组 1、元组个数 数组的定义格式为： 类型名 数组名 [常量表达式] 要注意一点，常量表达式里的值代表数组的个数，并不表示最大的下标值。 例如 int a[5]; 代表只能访问里面的[0]-[4] 其中，常量表达式里只要是整数或者整数子集就可以、 例如： int a['a']; 表示int a[97]; 但是遇到这样的： int n=100; int a[n]; 就会出现编译错误，因为在给n赋值的时候，改变了变量的性质。变量性
C++语法——数组
观则明的博客
10-03 2483
C++语法——数组
【C++基础语法入门】5 数组
qq_43058281的博客
02-01 306
【C++基础语法入门】5 数组5.1 概述5.2 一维数组5.2.1 定义方式5.2.2 一维数组名称用途5.2.3 冒泡排序5.3 二维数组5.3.1 二维数组定义方式5.3.2 二维数组数组名5.3.3 二维数组数应用案例 黑马程序员匠心之作|C++教程从0到1入门编程 学习笔记 目标：对C++有初步了解，能够有基础编程能力 案例：通讯录管理系统 5.1 概述 特点一：数组，就是一个集合，里面存放了相同类型的数据元素 特点二：数组是由连续的内存位置组成的 5.2 一维数组 5.2.1 定义方式 定义有三
c++数组用法.
个人进步之路
12-01 724
参考地址 为了提供原生数据类似功能/性能.元素直接放实例中,非堆上分配,编译期确定大小,编译器隐式声明构造/析构/赋值操作符. 自动推导数组大小 全局数组作配置参数,但得手动加上大小. 数组 g配置段={1,2,5,6,7,9,3,4}; 数组<正32型>g配置段={1,2,5,6,7,9,3,4}; 用函数模板代替类模板,c++函数模板允许部分推导. 元<型名 R,型名 P,整 N,整...I> 常式 数组<R,N>到数组实现(P(&a)[N],序列<I
C++基础语法：数组
baiyechangjiu的博客
08-18 1071
在C++语言中，数组可以存储一个固定大小的相同类型元素的顺序集合。所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。 数组的声明形式如下所示： type arrayName [ arraySize ]; type是任意类型的有效C++数据类型，而arraySize则是一个大于零的整数常量。 如果要访问指定位置的某一个元素的值，可以采用： arrayName[index] 数组的索引数值从0开始，而不是从1开始。 对数组的初始化可以逐个进行： #i
c语言基础-c语言编程基础之二维字符串数组示例-Bigtram分词.zip
03-17
本压缩包文件“c语言基础-c语言编程基础之二维字符串数组示例-Bigtram分词.zip”显然是围绕C语言的二维字符串数组以及Bigtram分词技术展开的教程或示例代码。下面我们将深入探讨这两个核心概念。 首先，我们来理解...
c语言如何生成字符型动态数组,C语言构建动态数组完整实例
weixin_39678531的博客
05-18 2057
C语言构建动态数组完整实例本文以一个完整的实例代码简述了C语言构建动态数组的方法，供大家参考，完整实例如下：#include #include int main(void) {int len;int * arr;printf("请输入数组长度:");scanf("%d", &len);arr = (int *)malloc(sizeof(int)*len);printf("请输入数组的值:...
C语言程序设计第4章数组和指针
04-09
字符数组用于存储字符串，因为字符串在C语言中被视为字符数组。例如，`char str[10] = "Hello";`。字符串常量末尾会自动添加空字符`\0`，因此存储"Hello"的数组实际长度为6（包括空字符）。 4. **多维数组**： ...
【C语言】案例五十二 字符串替换(一)【字符，字符串，字符数组】
yusihe的博客
08-31 2471
案例描述 字符串替换是处理字符串时最常见的操作之一，也是学习字符串必须掌握的知识。本案例要求通过编程实现字符串“Good moring”到“Good evening”的转换。 案例分析 我们需要从字符串中被替换的位置开始，将要替换的内容逐个复制到原字符串中，直到字符串结束或者替换的字符串结束为止。 为了顺利完成案例，需要先学习字符数组，字符串，字符指针等基础知识。 必备知识 1，字符数组 字符数组是存放字符数据的数组，其中每一个元素都是单个字符 （1）字符数组的定义 字符数组定义的语法格式如下： char
c语言数组与字符串PPT课件.pptx
10-06
C语言中的数组和字符串是程序设计的基础概念，广泛应用于数据存储和处理。在这个PPT课件中，主要讲解了数组的定义、初始化、赋值以及操作方法，同时也涉及到了二维数组和字符串的一些基本操作。 首先，数组是C语言...
C++基础语法之数组
最新发布
m0_75068978的博客
05-14 634
在C++中，一维数组是一系列具有相同数据类型的元素的集合。它们在内存中是连续存储的，可以通过索引访问每个元素。而二维数组是一个表格，由行和列组成。它是一系列具有相同数据类型的元素的集合，这些元素通过行和列的索引来访问。一维数组描述的是线性序列，二维数组描述的则是矩阵。
C++语法（六）一维数组与二维数组
Hillbox
09-05 224
一维数组 1、定义方式（3种） int arr[3]; int arr[3] = {1, 2, 3}; int arr[] = {1, 2, 3}; 2、取地址 // 首地址 cout << arr << endl; cout << &arr[0] << endl; 3、冒泡排序 总共用len个数组元素，则要进行len-1轮比较。 int arr[] = {4, 2, 1, 3, 9, 5, 7, 8, 6, 0}; int len
C++语法——指针和数组
山上有只羊M
08-18 528
int *a[22];// 定义22个指针，a[i](i=0,1,...,21)均为int类型的指针。
C/C++学习笔记（语法篇） 三、数组
weixin_42040046的博客
07-19 148
C/C++学习笔记（语法篇） 三、数组 数组
C++数组类指针的基本语法
New_new_zero的博客
01-14 326
//#include "stdafx.h" #include using namespace std; int main() { int a[10]; int(*at1)[10]; //定义一个指向数组类型的数组类指针 at1 = &a; (*at1)[0] = 1; cout 0]
C++学习之数组
时光の尘的博客
08-01 5514
数组就是一个集合，里面存放了相同类型的数据元素。定义方式可分为三种：1、数据类型 数组名 [ 数组长度 ]；2、数据类型 数组名 [ 数组长度 ] = {数值1，数值2，数值3……}；3、数据类型 数组名 [ ] = {数值1，数值2，数值3……}；1、数据类型 数组名 [ 数组长度 ]；int main()//数据类型 数组名 [ 数组长度 ]；int str[5];//注意其中5是数组长度，代表5个，而数组元素的下标是从0开始索引的。
使用c++超详细解释数据结构中的数组
Mr.林先生的博客
03-24 1687
数组是数据结构中最基本的数据类型之一，它是一组具有相同数据类型的数据元素的集合，每个元素可以通过一个索引（Index）来访问。在C++中，数组是一种固定大小的数据结构，可以使用数组名和索引来访问数组元素。下面我们来详细讲解数组在数据结构中涉及的所有知识点。
C++ 数组详解，很全，很详细
qq_44859843的博客
01-06 2541
数组是相同类型的对象序列，它们占据一块连续的内存区。传统的 C 样式数组是许多 bug 的根源，但至今仍很常用，尤其是在较旧的代码库中。在新式 C++ 中，我们强烈建议使用 std::vector或 std::array，而不是本部分所述的 C 样式数组。这两种标准库类型都将其元素存储为连续的内存块。但是，它们提供更高的类型安全性，并支持保证指向序列中有效位置的迭代器。
C++中数组定义及初始化
天涯遍地是小草的博客
06-25 881
一、一维数组 1.静态 int array[100]; 　　定义了数组array，并未对数组进行初始化 2.静态 int array[100] = {1，2}；　　定义并初始化了数组array 3.动态 int* array = new int[100]; delete []array;　　分配了长度为100的数组array 4.动态 int* array = new int100; ...
C语言基础整理：数组、字符串、函数与指针详解
接着，笔记详细介绍了C语言的一些基础知识，包括基本数据类型，如整型、浮点型等，以及如何处理数组和字符数组，这些都是C语言程序设计的基础。此外，函数是C语言的重要组成部分，这里对参数的传递方式进行了解析，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值