C++——数组与字符串

目录

• 一、数组
  • 1.1定义与初始化
    • 1.1.1使用
    • 1.1.2存储
    • 1.1.3初始化
  • 1.2作函数参数
  • 1.3对象数组
    • 1.3.1定义与访问
    • 1.3.2初始化
    • 1.3.3数组元素所属类的构造函数
• 二、字符串
  • 2.1字符数组（C风格）
    • 2.1.1字符型数据
    • 2.1.2字符数据的输入输出
    • 2.1.3字符数组
  • 2.2 string 类
    • 2.2.1常用构造函数
    • 2.2.2常用操作
    • 2.2.3输入整行字符串

一、数组

一组具有相同数据类型数据的有序集合
数组元素的类型称为该数组的基类型

1.1定义与初始化

语法形式类型说明符 数组名[常量表达式][常量表达式]……

1.1.1使用

先声明，后使用
只能逐个引用数组元素，而不能一次引用整个数组

1.1.2存储

1、一维数组
数组元素在内存中顺次存放，它们的地址是连续的。元素间物理地址上的相邻，对应着逻辑次序上的相邻
2、二维数组
按行存放，如float a[3][4]可理解为：
其中数组a的存储顺序为：a00 a01 a02 a03 a10 a11 a12 a13 a20 a21 a22 a23

1.1.3初始化

1、一维数组
在定义数组时给出数组元素的初始值

• 列出全部元素的初始值
• 只给一部分元素赋初值
• 在对全部数组元素赋初值时，可以不指定数组长度

//分别对应上面三个
static int a[10]={0,1,2,3,4,5,6,7,8,9};
static int a[10]={0,1,2,3,4};
static int a[]={0,1,2,3,4,5,6,7,8,9};

2、二维数组

• 将所有初值写在一个{}内，按顺序初始化
• 分组列出二维数组元素的初值
• 只对部分元素初始化
• 列出全部初始值时，第1维下标个数可以省略

//分别对应上面四个
static int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
static int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
static int a[3][4]={{1},{0,6},{0,0,11}};
static int a[][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};

如果不作任何初始化，内部auto型数组中会存在垃圾数据，static数组中的数据默认初始化为0
如果只对部分元素初始化，剩下的未显式初始化的元素，将自动被初始化为0

#include<iostream>
using namespace std;

const char key[] = { 'a', 'c', 'b', 'a', 'd' };
const int NUM = 5;

int main() {
    char c;
    int que = 0, correct = 0;
    cout << "Enter 5 answers:\n";
    while(cin.get(c)) {     //条件 " cin.get(c) " 中是句号而不是逗号
        if(c == '\n') {     //输入完通过回车显示结果，但换行符不能算作输入的内容
            cout << "\nScore " << (float)correct / NUM * 100 << "%\n";
            que = 0, correct = 0;   //计数器清零，且位于输出结果之后
        } else {
            if(c == key[que])
                correct++, cout << " "; //空格表示正确
            else
                cout << "*";    //星号表示错误
            que++;  //无论结果是否正确，数组下标都要后移
        }
    }
    return 0;
}

结果：
Enter 5 answers:
acbba
   **
Score 60%
acbad

Score 100%
abbda
 * **
Score 40%
bdcba
*****
Score 0%
^Z  //Ctrl + z 表示结束

1.2作函数参数

数组元素作实参，与单个变量一样
数组名作参数，形、实参数都应是数组名（实质上是地址），类型要一样，传送的是数组首地址

#include<iostream>
#include<cstdlib>
#include<ctime>     //第9行头文件
using namespace std;

void summary(int arr[][5], int n);

int main() {
    srand(time(NULL));  //产生随机数
    int arrey[3][5];
    for(int i = 0; i < 3; i++)
        for(int j = 0; j < 5; j++)
            arrey[i][j] = rand() % 10;
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 5; j++)
            cout << arrey[i][j] << ends;
        cout << endl;
    }
    summary(arrey,3);
    cout << "\n第一行和为：" << arrey[0][0] << endl
        << "第二行和为：" << arrey[1][0] << endl
        << "第三行和为：" << arrey[2][0] << endl;
    return 0;
}

void summary(int arr[][5], int n) { //注意向函数传递二维数组的方式
//  or int arr[][5] -> int (* arr)[5]
    for(int k = 0; k < n; k++)
        for(int m = 1; m < 5; m++)
            arr[k][0] += arr[k][m];
}

测试结果：（随机）
6 9 4 2 8
0 2 6 6 8
2 1 2 2 8

第一行和为：29
第二行和为：22
第三行和为：15 

1.3对象数组

1.3.1定义与访问

定义对象数组类名 数组名[元素个数]
访问对象数组元素数组名[下标].成员名

1.3.2初始化

数组中每一个元素对象被创建时，系统都会调用类构造函数初始化该对象
通过初始化列表赋值，如Point a[2]={Point(1,2),Point(3,4)};
如果没有为数组元素指定显式初始值，数组元素便使用默认值初始化（调用默认构造函数）

1.3.3数组元素所属类的构造函数

若元素所属的类不声明构造函数，则采用默认构造函数
各元素对象的初值要求为相同的值时，可以声明具有默认形参值的构造函数；各元素对象的初值要求为不同的值时，需要声明带形参的构造函数
当数组中每一个对象被删除时，系统都要调用一次析构函数

#include <iostream>
using namespace std;

class Point {
public:
    Point();
    ~Point();
    void move(int newX,int newY);
private:
    int x, y;
};

Point::Point() : x(0), y(0) {
    cout << "Default Constructor called" << endl;
}
Point::~Point() {
    cout << "Destructor called" << endl;
}
void Point::move(int newX,int newY) {
    x = newX, y = newY;
    cout << "Moving the point to (" << newX << ", " << newY << ")" << endl;
}

int main() {
    Point a[2]; //创建对象时调用构造函数初始化，且因为没有参数，调用的会是无参构造函数（如果有多个构造函数）
    for(int i = 0; i < 2; i++)
        a[i].move(i + 10, i + 20); //调用 move 函数赋值
    return 0;
}

结果：
Default Constructor called
Default Constructor called
Moving the point to (10, 20)
Moving the point to (11, 21)
Destructor called
Destructor called 

二、字符串

2.1字符数组（C风格）

2.1.1字符型数据

字符常量：用单引号括起来的一个字符，如'a'，'A'
字符变量：用char说明的变量
字符串常量：系统用字符数组的形式对其进行存储，各字符连续、顺序存放，每个字符占一个字节，以‘\0’结尾，相当于一个隐含创建的字符常量数组，如"China"，"123" 

2.1.2字符数据的输入输出

格式化输入输出函数：scanf()，printf()，"%c"
无格式输入输出函数：getchar()，putchar()

2.1.3字符数组

1、定义与初始化
语法形式char 数组名[维数说明]

char str[8] = { 'p', 'r', 'o', 'g', 'r', 'a', 'm', '\0' };
char str[8] = "program";
char str[] = "program";

2、引用
引用字符数组中的一个元素，得到一个字符
通过字符数组名字引用整个字符数组
3、字符串的输入输出
逐个字符输入输出，用 %c
整个字符串输入输出，用 %s
用 "%s" 格式符处理字符串时，scanf函数中的 输入项、printf函数中的输出项是字符数组名，如：printf("%s",a)
用 "%s" 格式符输入字符串时，scanf函数以空格作为分隔符
4、缺点
执行连接、拷贝、比较等操作，都需要显式调用库函数，很麻烦
当字符串长度很不确定时，需要用new动态创建字符数组，最后要用delete释放，很繁琐
字符串实际长度大于为它分配的空间时，会产生数组下标越界的错误

2.2 string 类

使用字符串类string表示字符串，string实际上是对字符数组操作的封装
string 并不是 C++ 语言本身具有的基本类型，它是在 C++ 标准库中声明的一个字符串类，用这种类可以定义对象，即每一个字符串变量都是 string 类的一个对象

2.2.1常用构造函数

string() 默认构造函数，建立一个长度为0的串，如string s1;
string(const char *s) 用指针s所指向的字符串常量初始化string对象，如string s2 = “abc”;
string(const string& rhs) 复制构造函数，如string s3 = s2;

2.2.2常用操作

• s + t 将串s和t连接成一个新串
• s = t 用 t 更新 s
• s == t 判断 s 与 t 是否相等
• s != t 判断 s 与 t 是否不等
• s < t 判断 s 是否小于 t（按字典顺序比较）
• s <= t 判断 s 是否小于或等于 t （按字典顺序比较）
• s > t 判断 s 是否大于 t （按字典顺序比较）
• s >= t 判断 s 是否大于或等于 t （按字典顺序比较）
• s[ i ] 访问串中下标为 i 的字符

string s1 = "abc", s2 = "def";

string s3 = s1 + s2;?   //结果是"abcdef"
bool s4 = (s1 < s2);    //结果是true
char s5 = s2[1];    //结果是'e'

2.2.3输入整行字符串

cin 的 >> 操作符输入字符串，以空格作为分隔符，空格后的内容会在下一回输入时被读取
getline可以输入整行字符串（要包string头文件），如：getline(cin, s2);
输入字符串时，可以使用其它分隔符作为字符串结束的标志（如逗号、分号），将分隔符作为getline的第3个参数即可，如：getline(cin, s2, ',')

string、string.h、cstring区别
string 是 C++ 的头文件，其内包含了一个 string 类，string s1 就是建立一个 string 类的对象
string.h 是旧的 C 头文件，对应的是基于 char* 的字符串处理函数
cstring 是对应于旧的 C 头文件的 std 版本，实际上只是在一个命名空间 std 中 include 了 string.h

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

inline void test(const char *title, bool value) {
    cout << title << " returns " << (value ? "true" : "false") << endl;
}

int main() {
    string s1 = "DEF";
    cout << "s1 is " << s1 << endl;
    string s2;
    cout << "Enter s2: ";
    cin >> s2;
    cout << "length of s2: " << s2.length() << endl;

    test("\ns1 <= \"ABC\"", s1 <= "ABC");
    test("\"DEF\" <= s1", "DEF" <= s1);

    s2 += s1;
    cout << "\ns2 = s2 + s1: " << s2 << endl;
    cout << "length of s2: " << s2.length() << "\n" << endl;

    string city, state;
    getline(cin, city, ',');
    getline(cin, state);
    cout << "City is " << city << "\tState is " << state << endl;
    return 0;
}

结果：
s1 is DEF
Enter s2: asdfjkl
length of s2: 7

s1 <= "ABC" returns false
"DEF" <= s1 returns true

s2 = s2 + s1: asdfjklDEF
length of s2: 10

hangZhou,zheJiang
City is hangZhou        State is zheJiang