c++数组

已于 2024-12-10 08:59:55 修改
阅读量2.4k 收藏 33
点赞数 32
CC 4.0 BY-SA版权
分类专栏： c++刷题知识点 文章标签： c++
于 2024-12-08 16:49:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73266891/article/details/144283731
数组是⼀组相同类型元素的集合；从这个概念中我们就可以发现2个有价值的信息：
  • 数组中存放的是1个或者多个数据，但是数组元素个数不能为0。
  • 数组中存放的多个数据，类型是相同的。

1. ⼀维数组

⼀维数组是最常⻅的，通常⽤来存放⼀组数据，⼀维数组是⼀块连续的空间。
f98dbc15b02c494a9c3e7fab14741f43.png
                                                 存放5个整型值的⼀维数组⽰意图

1.1 数组创建

⼀维数组创建的基本语法如下：

type arr_name[常量值];
存放在数组的值被称为数组的元素，数组在创建的时候需要指定数组的⼤⼩和数组的元素类型。
  • type 指定的是数组中存放数据的类型，可以是： char、short、int、float 等，也可以⾃ 定义的类型
  • arr_name 是数组的名字，这个名字可以⾃定义，根据实际情况，起的有意义就⾏。
  • [] 中的常量值是⽤来指定数组的⼤⼩的，数组的⼤⼩是根据实际的需求指定就⾏。在算法竞赛中 为了为了保证不越界访问，往往会多开辟⼀些空间，后期题⽬中会讲到。
  • 可以使⽤ const int N = 100 的⽅式定义常量，来指定数组的⼤⼩。
    •  例如： int arr[N] ;
⽐如：我们现在想存储某个班级的20⼈的数学成绩，那我们就可以创建⼀个数组，如下： 
int math[20];
//或者
const int N = 20;
int math[N];
当然我们也可以根据需要创建其他类型和⼤⼩的数组： 
1 char ch[8];
2 double score[10];

1.2 数组的初始化

有时候，数组在创建的时候，我们需要给定⼀些初始值，这种就称为初始化的。
那数组如何初始化呢？数组的初始化⼀般使⽤⼤括号，将数据放在⼤括号中。 
1 //完全初始化，数据会依次放⼊数组
2 int arr[5] = {1,2,3,4,5};
3
4 //不完全初始化
5 int arr2[6] = {1};//第⼀个元素初始化为1，剩余的元素默认初始化为0
6
7 //错误的初始化 - 初始化项太多
8 int arr3[3] = {1, 2, 3, 4};

1.3 数组元素访问

数组是有下标的，下标是从 0 开始的，假设数组有 n 个元素，最后⼀个元素的下标是 n-1 ，下标就 相当于数组元素的编号，如下： 
1 int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

8b2401b7f92f4a70b9a926a02f1e5c99.png

 
数组的访问提供了⼀个操作符 [] ，这个操作符叫：下标引⽤操作符。
有了下标访问操作符，我们就可以轻松的访问到数组的元素了，⽐如我们访问下标为7的元素，我们就 可以使⽤ arr[7] ，想要访问下标是3的元素，就可以使⽤ arr[3] ,如下代码： 
#include <iostream>
using namespace std;
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    cout << arr[7] << endl; // 8
    cout << arr[3] << endl; // 4
    return 0;
}

1.4 数组元素的打印

接下来，如果想要访问整个数组的内容，那怎么办呢？ 只要我们产⽣数组所有元素的下标就可以了，那我们使⽤ for 循环产⽣所有的下标，接下来使⽤下标 访问就⾏了。
  • 如果产⽣的下标超出了有效下标的范围，⽐如，使⽤负数作为下标，或者超出了下标 的最⼤值，再使⽤这个下标访问元素就会造成：越界访问。越界访问访问的时候，代码编译 时语法没报错，但是运⾏时⼀定会出问题的。

1.4.1 数组和sizeof

sizeof(数组名) ， 计算的是数组的总⼤⼩，单位是字节
sizeof(数组名)/sizeof(第⼀个元素) ，计算的是数组的元素个数 
#include <iostream>
using namespace std;
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    cout << sizeof(arr) << endl;   //40
    cout << sizeof(arr) / sizeof(arr[0]) << endl;   //10
    return 0;
}

1.4.2 数组元素的打印

#include <iostream>
using namespace std;
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int i = 0;
    for(i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)
    {
        cout << arr[i] << " ";
    }
    return 0;
}
//输出
//1 2 3 4 5 6 7 8 9 10

1.5 范围for

打印数组元素除了可以使⽤之前讲过的三种循环外，还有⼀个更⽅便的⽅式，使⽤范围 for 。范围 for是在 C++11 这个标准中引⼊的，如果你使⽤的编译器默认不⽀持 C++11 ，可能需要配置才能使 ⽤。以DevC++为例：打开工具里的编译器选项并加上-std=c++11命令即可

1.5.1 范围for语法

for ( 类型 变量名 : 数组名 )
语句 //多条语句需要加⼤括号
示例：打印数组 
#include <iostream>
using namespace std;
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    for (int e : arr)
    {
        cout << e << " ";
    }
    return 0;
}
//输出
//1 2 3 4 5 6 7 8 9 10
上⾯代码中的 for 就是范围for ，代码的意思是将 arr 数组中的元素，依次放在 e 变量中，然后 打印 e ，直到遍历完整个数组的元素。这⾥的 e 是⼀个单独的变量，不是数组的元素，所以对 e 的 修改，不会影响数组。但是对于范围 for 要慎重使⽤！范围 for 是对数组中所有元素进⾏遍历的，但是我们实际在做题的 过程中，可能只需要遍历数组中指定个数的元素，这样范围 for 就不合适了。

1.5.2 auto 关键字

auto 的主要⽤途是让编译器⾃动推导出变量的类型的，⽐如： 
#include <iostream>
using namespace std;
int main()
{
    auto a = 3.14;
    auto b = 100;
    auto c = 'x';
    return 0;
}
使⽤ auto 类型，上⾯的范围 for 也可以这样写： 
#include <iostream>
using namespace std;
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    for (auto e : arr) //auto能够⾃动推导数组中每个元素的数据类型，在数组范围内遍历打印元素
    {
        cout << e << " ";
    }
    return 0;
}
//输出
//1 2 3 4 5 6 7 8 9 10

00a556231efb4cde91698fc8b24d0b82.png

范围 for 中 e 前⾯的类型可以可以是 auto 关键字，当你不知道数组中放什么类型的时候，可以使⽤ auto 作为类型， auto 在范围 for 中很常⽤。如果明确的知道数组元素的数据类型，也可以将auto 换成对应的数据类型。

1.6 memset 设置数组内容

1.6.1 memset

函数原型如下： 
void * memset ( void * ptr, int value, size_t num );
参数解释：
ptr -- 指针：指向了要设置的内存块的起始位置
value -- 要设置的值
num -- 设置的字节个数
memset 是⽤来设置内存的，将内存中的值以字节为单位设置成想要的内容，需要头⽂件<cstring> 。

1.6.2 设置数组内容

#include <iostream>
#include <cstring>
using namespace std;
int main ()
{
    char str[] = "hello world";
    memset(str, 'x', 6);
    cout << str << endl;

    int arr[] = {1,2,3,4,5};
    memset(arr, 0, sizeof(arr));//这⾥数组的⼤⼩也可以⾃⼰计算
    for(auto i : arr)
    {
        cout << i << " ";
    }
    cout << endl;
    return 0;
}
//输出
//xxxxxxworld
//0 0 0 0 0

 b551f012cd5b4aadb436c2cc1bb41b67.png

1.6.3 错误使⽤

#include <iostream>
#include <cstring>
using namespace std;
int main ()
{
    int arr[] = {1,2,3,4,5};
    memset(arr, 1, 4 * sizeof(int));
    for(auto e : arr)
    {
        cout << e << " ";
    }
    cout << endl;
    return 0;
}
//输出
//16843009 16843009 16843009 16843009 5

230f1703fec0455983e6e052ecf3cf72.png

从上⾯打印结果可以看出，当value设置为1或者其他⾮0的数字时，打印结果不符合预期。主要原因是 memset 函数是给每个字节设置 value 值，⽽⼀个整型元素占⽤4个字节，⼀个整型的每个字节都被设置为1，⼆进制就是：00000001000000010000000100000001 ，转换成⼗进制就是： 16843009 ，因此结果是不符合预期的。

20a27b4f29d947aebf17d62df7f5ef4c.png

    int的4个字节，每个字节都被设置为1

1.7 memcpy 拷⻉数组内容

在使⽤数组的时候，有时候我们需要将数组a的内容给数组b，⽐如： 
int a[10] = {1,2,3,4,5,6,7,8,9,10};
int b[10] = {0};

a046f03e0c8145aa986f332181160687.png

怎么做呢？b = a; 直接赋值可以吗？不⾏！
其实C++中有⼀个库函数 memcpy 可以做数组内容的拷⻉，当然 memcpy 其实是⽤来做内存块的拷⻉的，当然⽤来做数组内容的拷⻉也是没问题的。memcpy需要的头⽂件是 <cstring> 。函数原型如下： 
void * memcpy ( void * destination, const void * source, size_t num );
//destination -- ⽬标空间的起始地址
//source -- 源数据空间的起始地址
//num -- 拷⻉的数据的字节个数
代码举例： 
#include <iostream>
#include <cstring>
using namespace std;
int main()
{
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
    int b[10] = {0};
    memcpy(b, a, 10 * sizeof(int));
    for(int e: b)
    {
        cout << e << " ";
    }
    return 0;
}
//输出
//1 2 3 4 5 6 7 8 9 10
  • 当然如果拷⻉ double 类型的数组时，计算时应该使⽤ sizeof(double) ，要灵活变化。

2. ⼆维数组

2.1 ⼆维数组的概念

前⾯学习的数组被称为⼀维数组，数组的元素都是内置类型的，如果我们把⼀维数组做为数组的元素，这时候就是⼆维数组，⼆维数组作为数组元素的数组被称为三维数组，⼆维数组以上的数组统称为多维数组。

f21935463cb24efda0ec21ee4917bdb8.png

                                                  整型、整型⼀维数组、整型⼆维数组 

2.2 ⼆维数组的创建

那我们如何定义⼆维数组呢？语法如下： 
type arr_name[常量值1][常量值2]；
例如： 
int arr[3][5];
double data[2][8];
下⾯解释⼀下上述代码中的⼀些关键信息：
  • 3 表⽰数组有 3 ⾏
  • 5 表⽰每⼀⾏有 5 个元素
  • int 表⽰数组的每个元素是整型类型
  • arr 是数组名，可以根据⾃⼰的需要指定名字，data 数组意思基本⼀致。

2.3 ⼆维数组的初始化

在创建变量或者数组的时候，给定⼀些初始值，被称为初始化。那⼆维数组如何初始化呢？像⼀维数组⼀样，也是使⽤⼤括号初始化的。 
//不完全初始化
int arr1[3][5] = {1,2};
int arr2[3][5] = {0};
//完全初始化
int arr3[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};
//按⾏初始化
int arr4[3][5] = {{1,2},{3,4},{5,6}};
//如果数组初始化了，数组在指定⼤⼩的时候可以省略⾏，⽽不能省略列
int arr5[][5] = {1,2,3};
int arr6[][5] = {1,2,3,4,5,6,7};
int arr7[][5] = {{1,2}, {3,4}, {5,6}};

2.4 ⼆维数组的下标

当我们掌握了⼆维数组的创建和初始化，那我们怎么使⽤⼆维数组呢？其实⼆维数组访问也是使⽤下标的形式的，⼆维数组是有⾏和列的，只要锁定了⾏和列就能唯⼀锁定数组中的⼀个元素。C/C++规定，⼆维数组的⾏是从 0 开始的，列也是从 0 开始的，如下所⽰： 
int arr[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};

f9f380517e904621b7cb7fcea075a9f4.png

图中最右侧绿⾊的数字表⽰⾏号，第⼀⾏蓝⾊的数字表⽰列号，都是从 0 开始的，⽐如，我们说：第2⾏，第4列，快速就能定位出7。 
#include <iostream>
using namespace std;

int main()
{
    int arr[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};
    cout << arr[2][4] << endl;   //7
    return 0;
}

2.5 ⼆维数组元素的遍历和打印

#include <iostream>
using namespace std;
int main()
{
    int arr[3][5] = { 1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7 };
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}
//输出
//1 2 3 4 5
//2 3 4 5 6
//3 4 5 6 7

2.6 使⽤memset 设置⼆维数组内容

memset 是⽤来设置内存的，将内存中的值以字节为单位设置成想要的内容。
下⾯演⽰两个例⼦，使⽤ memset 来设置⼆维数组的内容
  
#include<iostream>
#include <cstring>
using namespace std;
int main()
{
    int a[10][10];
    memset(a, 0, sizeof(a)); //将⼆维整型数组中每个字节都设置为0
    for(int i = 0; i < 10; i++)
    {
        for(int j = 0; j < 10; j++)
        {
            cout << a[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}
//输出
//0 0 0 0 0 0 0 0 0 0
//0 0 0 0 0 0 0 0 0 0
//0 0 0 0 0 0 0 0 0 0
//0 0 0 0 0 0 0 0 0 0
//0 0 0 0 0 0 0 0 0 0
//0 0 0 0 0 0 0 0 0 0
//0 0 0 0 0 0 0 0 0 0
//0 0 0 0 0 0 0 0 0 0
//0 0 0 0 0 0 0 0 0 0
//0 0 0 0 0 0 0 0 0 0

#include<iostream>
#include <cstring>
using namespace std;
int main()
{
    char a[10][10];
    memset(a, 'a', sizeof(a)); //将二维字符数组中每个字节都设置为字符a
    for(int i = 0; i < 10; i++)
    {
        for(int j = 0; j < 10; j++)
        {
            cout << a[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}
//输出
//a a a a a a a a a a
//a a a a a a a a a a
//a a a a a a a a a a
//a a a a a a a a a a
//a a a a a a a a a a
//a a a a a a a a a a
//a a a a a a a a a a
//a a a a a a a a a a
//a a a a a a a a a a
//a a a a a a a a a a
  • memset 在⼆维数组中的⽤法同⼀维数组，同样也需要注意避免给整型赋⾮ 0 值。

3. 字符数组

3.1 字符数组介绍

数组的元素如果是字符类型，这种数组就是字符数组，字符数组可以是⼀维数组，可以是⼆维数组（多维数组）。接下来主要讨论⼀维的字符数组。 
char arr1[5]; //⼀维数组
char arr2[3][5];//⼆维数组
C 语⾔中使⽤双引号括起来⼀串字符表⽰字符串，这种⽅式虽然在 C++ 中也是⽀持的，但是⼀般我们会将这种字符串称为 C 语⾔⻛格的字符串。如果需要将⼀个 C 语⾔⻛格的字符串存储起来，就可以是字符数组。

3.1.1 字符数组的初始化

char a[10]; //字符数组的创建
字符数组的创建同⼀维数组的创建就不再赘述，但是字符串数的初始化有2种⽅式，如下： 
//⽅式1
char ch1[10] = "abcdef";
char ch2[] = "abcdef";//如果数组初始化的时候，数组的⼤⼩可以省略不写，数组⼤⼩会根据初 始化内容来确定
//⽅式2
char ch3[10] = {'a', 'b', 'c', 'd', 'e', 'f'};
char ch4[] = {'a', 'b', 'c', 'd', 'e', 'f'};
如果调试看⼀下 ch2 和 ch4 数组的内容，我们会明显的发现，数组 ch2 中多⼀个 '\0' 字符，这是因为字符串的末尾其实隐藏⼀个 '\0' 字符，这个 '\0' 是字符串的结束标志，在打印字符串的时候遇到 '\0' ，打印结束。当我们把字符串存放在⼀个字符数组中的时候，这时候也可以把字符数组当做字符串看到。

57df3cbdf29249398a2486454f4e5539.png 

3.1.2 字符串⻓度-strlen

字符数组中存放的着字符串，这个字符数组有⾃⼰的⻓度，也就是数组的元素个数，这个可以使⽤sizeof 计算，那数组中存放的字符串的⻓度是多少？怎么来计算呢？其实C/C++中有⼀个库函数叫： strlen ，可以求字符串的⻓度，其实统计的就是字符串中 \0 之前的字符个数。 strlen 需要的头⽂件是 <cstring> 。 
size_t strlen ( const char * str );
//str - 指针，存放的是字符串的起始地址，从这个地址开始计算字符串的⻓度
代码演示： 
#include <iostream>
#include <cstring>
using namespace std;
int main()
{
    char arr[20] = "abcdef";
    cout << "数组的⻓度:" << sizeof(arr)/sizeof(arr[0]) << endl;
    cout << "字符串的⻓度:" << strlen(arr) << endl;

    return 0;
}
//数组的长度:20
//字符串的长度:6

3.2 字符数组的输⼊

3.2.1 输⼊没有空格字符串

使⽤scanf函数和字符数组来实现： 
#include <cstdio>
int main()
{
    char arr[20] = { 0 };
    //输⼊
    scanf("%s", arr);
    //输出
    printf("%s", arr);
    return 0;
}
//输出
//asd
//asd
使⽤cin和字符数组来实现： 
#include <iostream>
using namespace std;
int main()
{
    char arr[20] = { 0 };
    //输⼊
    cin >> arr;
    //输出
    cout << arr << endl;
    return 0;
}
//输出
//asd
//asd
上⾯两个代码都是将字符串读取后从数组的起始位置开始存放的，当然也可以指定位置存放，⽐如从数组的第⼆个元素的位置开始存放，如下代码： 
#include <iostream>
using namespace std;
int main()
{
    char arr[20] = { 0 };
    //输⼊
    cin >> arr + 1;//arr表⽰数组的起始位置，+1意思是跳过⼀个元素，就是第⼆个元素的位置
    //可以通过调试观察⼀下arr的内容
    cout << arr + 1;
    return 0;
}
//输出
//abc
//abc
那么从第n个元素开始存放，就应该是 cin >> arr + n; 使⽤ scanf 函数也是⼀样的。 
#include <cstdio>
int main()
{
    char arr[20] = { 0 };
    //输⼊
    scanf("%s", arr+2);//从arr+2的位置开始存放
    //输出
    printf("%s", arr+2);//从arr+2的位置开始打印
    return 0;
}
//输出
//abc
//abc

3.2.2 输⼊有空格的字符串

3.2.2.1 发现问题
前⾯我们讲解了 scanf 和 cin 读取不含空格的字符串，⼀切都正常，⾮常简单。那当我们输⼊的字符串中有空格，会怎么样呢？
3.2.2.1.1 scanf的⽅式 
#include <cstdio>
int main()
{
    char arr[20] = {0};
    //输⼊
    scanf("%s", arr);
    //输出
    printf("%s", arr);
    return 0;
}
//输出
//abc def
//abc
当输⼊"abc def"的时候，实际上scanf只读取了abc就结束了，也就是相当于遇到空格就结束了。这⾥特别说⼀下占位符 %s ，它其实不能简单地等同于字符串。它的规则是，从当前第⼀个⾮空⽩字符开始读起，直到遇到空⽩字符（即空格、换⾏符、制表符等）为⽌。因为 %s 的读取不会包含空⽩字符，所以⽆法⽤来读取多个单词，除⾮多个 %s ⼀起使⽤。这也意味着， scanf() 不适合读取可能包含空格的字符串，⽐如书名或歌曲名。另外有⼀个细节注意⼀下， scanf() 遇到 %s 占位符，会在字符串变量末尾存储⼀个 \0 字符。同时 scanf() 将字符串读⼊字符数组时，不会检测字符串是否超过了数组⻓度。所以，储存字符串时，很可能会超过数组的边界，导致预想不到的结果。为了防⽌这种情况，使⽤ %s 占位符时，可以指定读⼊字符串的最⻓⻓度，即写成 %[m]s ，其中的 [m] 是⼀个整数，表⽰读取字符串的最⼤⻓度，后⾯的字符将被丢弃。 
#include <cstdio>
int main()
{
    char name[11];
    scanf("%10s", name);
    return 0;
}
//输出
//asdasdasdasd
//asdasdasda
上⾯⽰例中， name 是⼀个⻓度为11的字符数组，scanf() 的占位符 %10s 表⽰最多读取⽤⼾输⼊的10个字符，后⾯的字符将被丢弃，这样就不会有数组溢出的⻛险了。
3.2.2.1.2 cin的⽅式 
#include <iostream>
using namespace std;
int main()
{
    char arr[20] = { 0 };
    //输⼊
    cin >> arr;
    //输出
    cout << arr << endl;
    return 0;
}
//输出
//abc def
//abc
结果也是⼀样，没有任何区别。其实cin在读取⼀个字符串的时候，在遇到空⽩字符的时候，就认为字符串结束了，不再继续往后读取剩余的字符，同时将已经读取到的字符串末尾加上\0，直接存储起来。
3.2.2.2 解决问题
3.2.2.2.1 gets 和 fgets
使⽤ gets 函数的⽅式，这种⽅式能解决问题，但是因为 gets 存在安全性问题，在C++11中取消了gets ，给出了更加安全的⽅案： fgets 。 
char * gets ( char * str );
char * fgets ( char * str, int num, FILE * stream );
1. gets 是从第⼀个字符开始读取，⼀直读取到 \n 停⽌，但是不会读取 \n ，也就是读取到的内容中没有包含 \n ,但是会在读取到的内容后⾃动加上 \0 。
2. fgets 也是从第⼀个字符开始读取，最多读取 num-1 个字符，最后⼀个位置留给 \0 ，如果num 的⻓度是远⼤于输⼊的字符串⻓度，就会⼀直读取到 \n 停⽌，并且会读取 \n ，将 \n 作为读取到内容的⼀部分，同时在读取到的内容后⾃动加上 \0 。 
#include <cstdio>
//⽅案1
int main()
{
    char arr[10] = {0};
    gets(arr);
    printf("%s\n", arr);
    return 0;
}
//输出
//asda asd
//asda asd

//替代⽅案-⽅法2
#include <cstdio>
int main()
{
    char arr[10] = {0};
    fgets(arr, sizeof(arr), stdin);
    printf("%s\n", arr);
    return 0;
}
//输出
//asda asda
//asda asda
上述两个程序，同样在运⾏起来后，在控制台窗⼝中输⼊： abc def ，按回⻋，⽅案1和⽅案2中arr 数组的内容中差异如下：

 0648f0769e2c4483b438923aad7e7e99.png

 
有些编译器使⽤gets函数有报错，⽐如：VS2022上直接报错，不允许使⽤gets函数。所以在代码中还是慎⽤gets函数。

                0077eec3a17147daa0bc876ed0e14930.png 

                                                        gets在VS2022上的报错
3.2.2.2.2 scanf

当然C语⾔中使⽤ scanf 函数其实也能做到读取带有空格的字符串，只是不常⻅⽽已。⽅式就是将 "%s" 改成 "%[^\n]s" ，其中在 % 和 s 之间加上了 [^\n] ，意思是⼀直读取，直到遇到\n ，这样即使遇到空格也就不会结束了。这种⽅式读取，不会将 \n 读取进来，但是在读取到的字符串末尾加上 \0 。

#include <cstdio>
int main()
{
    char arr[10] = "xxxxxxxx";
    scanf("%[^\n]s", arr);
    printf("%s\n", arr);
    return 0;
}
//输出
//abc def
//abc def
3.2.2.2.3 getchar
使⽤ getchar 逐个字符的读取，也是可以读取⼀个字符串的。 
#include <cstdio>
int main()
{
    char arr[10] = { 0 };
    int ch = 0;
    int i = 0;
    while ((ch = getchar()) != '\n')
    {
        arr[i++] = ch;
    }
    printf("%s\n", arr);
    return 0;
}
//输出
//abc def
//abc def

3.3 字符数组的输出

1. C 语⾔中可以在 printf 函数中使⽤ %s 占位符的⽅式，打印字符数组中的字符串。
2. C++ 中使⽤ cout ，可以直接打印字符数组中的字符串内容。
3. 也可以采⽤循环的⽅式逐个字符打印字符串的内容。 
//⽅法1
#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
    char a[] = "hello world";
    cout << a << endl;
    printf("%s\n", a);
    return 0;
}
//输出
//hello world
//hello world

//⽅法2
//单个字符的打印，直到\0字符,\0不打印
#include <iostream>
using namespace std;
int main()
{
    char a[] = "hello world";
    int i = 0;
    while (a[i] != '\0')
    {
        cout << a[i];
        i++;
    }
    cout << endl;
    return 0;
}
//输出
//hello world
//hello world

//⽅法3
//单个字符打印，根据字符串⻓度来逐个打印
//strlen可以求出字符串的⻓度，不包含\0
#include <iostream>
#include <cstring>
using namespace std;
int main()
{
    char a[] = "hello world";
    int i = 0;
    for (i = 0; i < strlen(a); i++)
    {
        cout << a[i];
    }
    cout << endl;
    return 0;
}
//输出
//hello world
//hello world

3.4 strcpy 和 strcat

3.4.1 strcpy

使⽤字符数组可以存放字符串，但是字符数组能否直接赋值呢？⽐如： 
char arr1[] = "abcdef";
char arr2[20] = {0};
arr2 = arr1;//这样这节赋值可以吗？
就⾏整型数组中，我们说的过⼀样，这⾥也是不⾏的。那么如何将arr1中的字符串，拷⻉到arr2中呢？其实C/C++中有⼀个库函数叫strcpy，可以完成。 
char * strcpy ( char * destination, const char * source );
//destination - 是⽬标空间的地址
//source - 是源头空间的地址
//需要的头⽂件 <cstring>
代码演示： 
#include <cstdio>
#include <cstring>
int main()
{
    char arr1[] = "abcdef";
    char arr2[20] = {0};
    strcpy(arr2, arr1);
    printf("%s\n", arr2);
    return 0;
}
//输出
//abcdef

3.4.2 strcat

有时候我们需要在⼀个字符的末尾再追加⼀个字符串，那字符数组能直接追加吗？⽐如： 
char arr1[20] = "hello ";
char arr2[] = "world";
arr1 += arr2;//这样也是不⾏的
那怎么办呢？C/C++中有⼀个库函数叫strcat，可以完成。 
char * strcat ( char * destination, const char * source );
//destination - 是⽬标空间的地址
//source - 是源头空间的地址
//需要的头⽂件 <cstring>
代码演示： 
#include <cstdio>
#include <cstring>
int main()
{
    char arr1[20] = "hello ";
    char arr2[] = "world";
    strcat(arr1, arr2);
    printf("%s\n", arr1);
    return 0;
}
//蔬菜
//hello world
除了上⾯的两个字符串相关函数外，其实C/C++中还提供了⼀些其他的函数，有兴趣的伙伴可以拓展学习： <cstring> (string.h) - C++ Reference
 

 

C++数组（数组定义方式、数组名作用、数组地址）
NewsomTech
12-26 9万+
文章目录1 数组概述2 一维数组2.1 一维数组定义方式2.2 一维数组数组名2.3 冒泡排序3 二维数组3.1 二维数组定义方式3.2 二维数组数组名3.3 二维数组应用案例 1 数组概述 数组是一个集合，用于存放相同类型的数据元素。 特点1：数组中的每个数据元素具有相同的数据类型。 特点2：数组占用一段连续的内存空间。 2 一维数组 2.1 一维数组定义方式 注1：数组名的命名规范与变量名命名一致，且数组名不能与变量重名。 注2：数组的下标/索引从0开始。 一维数组定义的3种方式： （1）数据类
如何给6个整数的一维数组某个元素赋值_C++基础知识篇：C++ 数组
weixin_40009207的博客
12-17 1488
C++ 支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。数组的声明并不是声明一个个单独的变量，比如 number0、number1、...、number99，而是声明一个数组变量，比如 numbers，然后使用 numbers[0]、numbers[1]、...、numbers[99] 来代表一个个单独的变量。数组中...
【C++基础】数组
分享是一种境界，勤于分享，乐于分享！
03-10 1113
C++中的数组是一种数据结构，用于存储相同类型元素的固定大小的集合。数组在内存中占据连续的存储位置，使得访问元素时效率较高。了解C++语言中数组，对学习C++编程很重要。所以，本文对C++语言中数组进行简单的介绍。众所周知，C++ 是一种‌通用、高性能的编程语言‌，支持‌多范式编程‌（面向对象、泛型、过程化），由本贾尼·斯特劳斯特卢普（ ‌‌ ）于 1985 年基于 C 语言扩展而来。官网地址：https://cplusplus.com/doc/
C++中的数组
最新发布
qq2745567641的博客
06-08 889
本文详细介绍了C++中数组的使用方法。主要涵盖一维数组的定义、初始化和遍历，多维数组的内存布局与访问方式，以及数组与指针的关系，包括动态数组的内存管理。文章还探讨了数组作为函数参数的传递方式，并推荐使用std::array和std::vector作为更安全的替代方案。最后总结了数组使用的常见陷阱，建议优先使用标准库容器以避免内存泄漏和越界访问等问题。这篇指南适合需要深入理解C++数组特性的开发者参考。
c++ 数组
luoganttcc的博客
03-13 285
c++ 数组 #include <iostream> using namespace std; #include <iomanip> using std:: setw; int main() { int n[10]; //初始化数组元素 for (int i=0;i...
C++数组
Hu3106547813的博客
10-22 929
C++数组
C++之数组
weixin_45984283的博客
04-12 9283
C++基础之数组
[c++]数组
weixin_60479183的博客
01-17 3049
[c++]数组
C++ 数组
AusrEnder的博客
05-03 844
数组,就是一个集合,用于存放相同类型的数据元素.
C++ 数组
小肥羊快快跑
06-03 523
数组定义静态数组（固定长度）：type var_name[size];其中type定义了数组的基本数据类型，即各元素的数据类型，size定义了数组的元素数目。必须是常数或常数变量。动态数组（不定长度）：（1）new方法一维数组：cin&lt;&lt;size;type* var_name = new type[size];其中new本就是用来开辟动态空间的，这里可看作是分配了一个大小为size的未...
c++---数组
m0_50046535的博客
04-07 3296
概念：一个集合，里面存放了相同类型的数据元素 特点： 1.数组中的每个数据元素都是相同的数据类型 2.数组是由连续的内存位置组成的 一.一维数组 1. 一维数组定义三种方式： 1、数据类型 数组名[数组长度]； 2、数据类型 数组名[数组长度] = {值1，值2，...}； 3、数据类型 数组名[] = {值1，值2，...}； int main() { //初始化数组没有填写数据，会用0来填补数据 i...
C++学习之数组
时光の尘的博客
08-01 5729
数组就是一个集合，里面存放了相同类型的数据元素。定义方式可分为三种：1、数据类型 数组名 [ 数组长度 ]；2、数据类型 数组名 [ 数组长度 ] = {数值1，数值2，数值3……}；3、数据类型 数组名 [ ] = {数值1，数值2，数值3……}；1、数据类型 数组名 [ 数组长度 ]；int main()//数据类型 数组名 [ 数组长度 ]；int str[5];//注意其中5是数组长度，代表5个，而数组元素的下标是从0开始索引的。
c++中的数组
m0_64703222的博客
04-24 737
数据类型 数组名 [数组长度]；数据类型 数组名[数组长度] ={值1，值2，...}；数据类型 数组名[ ] ={值1，值2，...}；int main()//数组//数据类型 数组名[数组长度]；arr[0] = 1;//数据类型 数组名[数组长度] = { 值1，值2，... }；//默认为0//用for循环遍历数组i < 10;i++)//数组下标从0开始索引//数据类型 数组名[] = { 值1，值2，... }；arr2[4]=5;//修改数组元素。
C++_数组类型
weixin_34391445的博客
02-16 161
数组定义由类型名、标识符和维数组成。维数指定数组中包含的元素的数目，它被写在一对方括号里面。维数值必须是常量表达式。 int ia [10]; //声明了一个包含10个int对象的数组 数组是一个单一数据类型对象的集合。 其中单个对象并没有被命名，但是我们可以通过它在数组中的位置对它进行访问。 这种访问形式叫做索引访问（下标访问）。 每个对象被称为是ia...
「C++系列」数组
日常笔记/总结/系列知识梳理
07-29 2743
你可以通过传递指向数组的指针来模拟这种行为，或者如果你在处理的是固定大小的数组，并且希望避免传递大小参数，你可以考虑使用模板（但这不是传递数组的“引用”，而是类型推导）。在C++中，指向数组的指针是一个特殊的指针，它指向数组的第一个元素的地址。然而，需要注意的是，指针本身并不知道它所指向的数组的大小，这意味着在通过指针遍历数组时，我们需要知道何时停止，以避免越界访问。然而，这种方法有局限性，因为它返回的总是同一个数组的引用，可能在多线程环境下导致问题，并且数组的大小在编译时就已确定。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值