C++中的数组与字符串

一、数组 

 1.声明数组的语法

typeName arrayName[arraySize]

注意：表达式arraySize指定元素数目，它必须是整形常数（如10）或者const值，也可以是常量表达式（如8*sizeof(int)）,即其中所有的值在编译时都是已知的，或者说arraySize不能是变量。可以使用new运算符来解决这类问题。

2.初始化数组

 1）初始化列表法：只有在定义数组时才能使用此方法

int card[4] = { 3,4,3,4 };

2）利用下标分别给数组中的元素赋值

3. 几点注意

1.不能将一个数组的值赋给另一个数组。

int card[4] = { 3,4,3,4 };
	int hand[4];
	hand[4] = { 6,7,8,9 };//not allowed
	hand = card;//not allowed

 2.初始化数组时，提供的值可以少于数组的元素数目，编译器会自动将剩余的元素设置成0；

因此，将数组中元素都设置成0，可以采用：

int card[4] = { 0 };

3.尽量不要使用这种语法：

int hand[] = { 6,7,8,9 };

4.C++11数组初始化方法

1）初始化数组时，等号可以省略

double earning[4]{1.2e4,1.6e4,1.1e4,1.7e4};

2)可不在大括号中包含任何东西，这将把所有元素都设置为零

float balance[100]{};

3)列表初始化禁止缩窄转化

long plifs[]={25,92,3.0};

字符串 

一、前言

C++中有两种风格字符串，分别是：

• C++风格字符串
• C风格字符串

它们各自的声明方式如下：

void main(){
    string a = "hello";    //C++风格
    char *b = "hello";　　//C风格   字符串数组
    char c[] = "hello";　　//C风格 字符串常量
    const char* d[]="hello"  //c风格
}

二、C风格字符串

C风格字符串声明：
字符串数组：
char c[20(可省)]={'c', '  ', 'p', 'r', 'o', 'g', 'r', 'a','m'};  
char str[30（可省）] = {"c.biancheng.net"};  //大括号可以省

字符串常量：
char *str = "abdc";
或者
char *str;
str = "abcd";

//C语言有两种表示字符串的方法，一种是字符数组，另一种是字符串常量，它们在
内存中的存储位置不同，使得字符数组可以读取和修改，而字符串常量只能读取不能修改。

 1.第一种定义字符串的方式

char dog[8]={'a','e','c','e','f','d','g','b'};//not a string
char cat[8]={'a','e','c','e','f','d','g','\0'};//a string

注意：这两个数组都是char 数组，但只有第二个数组是字符串。C-风格字符串具有一种特殊的性质：以空字符 ’\0' 结尾。

 2.第二种定义字符串的方式

char bird[11]="Mr.Cheeps";//the \0 is understood
char fish[]="Bubbles";//let the comiler count

 不用大量使用单引号，以及空字符

注意：1、字符常量（如‘s'）是字符串编码的简写表示。在ASCII系统上，只是83的另一种的表示，因此下面的语句是将83赋给shirt_size

char shirt_size ='S';

2、”S"不是字符常量，它表示两个字符（字符S和\0）组成的字符串。

char shirt_sizr ="S";//illegal type mismatch

3、这里需要留意一个坑，字符数组只有在定义时才能将整个字符串一次性地赋值给它，一旦定义完了，就只能一个字符一个字符地赋值了。请看下面的例子：

#include <iostream>
#include <cstring>
int main()
{
 char str[7];
//str = "abc123";  //错误
//正确
str[0] = 'a'; str[1] = 'b'; str[2] = 'c';
str[3] = '1'; str[4] = '2'; str[5] = '3';
std::cout <<str[0]<<sizeof(str)<<std::endl;
}

参考资料：C语言字符数组和字符串详解

  C语言字符串指针（指向字符串的指针）详解

三、C++风格字符串

一、定义 

C++ 大大增强了对字符串的支持，除了可以使用C风格的字符串，还可以使用内置的 string 类。string 类处理起字符串来会方便很多，完全可以代替C语言中的字符数组或字符串指针。

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

int main()
{
    string s1;//变量 s1 只是定义但没有初始化，编译器会将默认值赋给 s1，默认值是""，也即空字符串。
    string s2 = "c plus plus";//变量 s2 在定义的同时被初始化为"c plus plus"。与C风格的字符串不同，string 的结尾没有结束标志'\0'。
    string s3 = s2;//变量 s3 在定义的时候直接用 s2 进行初始化，因此 s3 的内容也是"c plus plus"。
    string s4 (5, 's');//变量 s4 被初始化为由 5 个's'字符组成的字符串，也就是"sssss"。
    return 0;
}

二、一些性质

1、赋值

不能将一个数组赋给另一个数组，但可以将一个string对象赋给另一个string对象

char charr1[20];
char charr2[20]="jaguar";
string str1;
string str2="panther";
charr1=charr2; //invalid
str1=str2;    //valid

2、拼接and附加 

string类简化了字符串合并操作，可以直接使用+将两个string对象合并起来，还可以使用运算符+=将字符串附加到string对象的末尾，不需要像char型数组需要使用函数。

string str1 ,str2,str3;
str3=str1+str2;
str1+=str2;

参考文献：C++ string详解，C++字符串详解

C++ 字符串与字符数组 详解_ZeroZone零域的博客-CSDN博客_c++字符串数组

模板类vector

存在的原因：在使用数组进行编程时，会存在两个问题：不安全不方便，如下标越界、两个数组赋值要用循环一个个赋值，数组大小不可以变化等。

一、定义

本质定义：vector<typeName>vt(n_elem)

一些拓展与延申
    (1) vector<int> a(10); //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型），但没有给出初值，其值是不确定的。
   （2）vector<int> a(10,1); //定义了10个整型元素的向量,且给出每个元素的初值为1
   （3）vector<int> a(b); //用b向量来创建a向量，整体复制性赋值
   （4）vector<int> a(b.begin(),b.begin+3); //定义了a值为b中第0个到第2个（共3个）元素
   （5）int b[7]={1,2,3,4,5,9,8};
        vector<int> a(b,b+7); //从数组中获得初值

二、初始化

1、vector<T> v5{a,b,c...};         //包含初始化元素个数，每个元素被对应的赋予相应的值
2、vector<T> v5={a,b,c...};        //等价v5{a,b,c...}

利用vector的成员函数push_back初始化对象：

vector<int> v;
for(int i = 0; i != 100; ++i)
{
    v.push_back(i);
    
}

删改数据 

增加数据

• void push_back(const T& x):向量尾部增加一个元素X
• iterator insert(iterator it,const T& x):向量中迭代器指向元素前增加一个元素x
• iterator insert(iterator it,int n,const T& x):向量中迭代器指向元素前增加n个相同的元素x
• iterator insert(iterator it,const_iterator first,const_iterator last):向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据

 

删除数据

• iterator erase(iterator it):删除向量中迭代器指向元素
• iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
• void pop_back():删除向量中最后一个元素
• void clear():清空向量中所有元素

安全性问题

数组使用[]来访问数组内的元素，会产生越界访问，采用at（）函数可以有效避免此类问题，比[]更加安全。 

vector<int> v(5, 1);
 
for(int i = 0; i < 10; i++){
    cout << "Element " << i << " is " << v[i] << endl;
}

这段代码访问了vector末尾以后的元素,这将可能导致很危险的结果.以下的代码将更加安全: 
vector<int> v(5, 1);
 
for(int i = 0; i < 10; i++){
    cout << "Element " << i << " is " << v.at(i) << endl;
}

C++Vector各函数作用 – 梁笔记

但是由于使用vector代替数组时，虽然可以避免安全性不方便等问题，但是由于数组存储在内存区域（栈）中，vector对象存储在自由存储区（堆），造成vector效率没有数组高，那么就引申出array容器，即安全方便，又有效率。和其他容器的区别是，array的大小是固定的，无法动态扩展或者收缩。这也就意味着，在使用该容器的过程无法借由增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。在使用该容器之前，代码中需引入 <array> 头文件

定义：

#include <array>
std::array<double, 10> values;

初始化

通过如下创建 array 容器的方式，可以将所有的元素初始化为 0 或者和默认元素类型等效的值：

std::array<double, 10> values {};

当然，在创建 array 容器的实例时，也可以像创建常规数组那样对元素进行初始化：

std::array<double, 10> values {0.5,1.0,1.5,2.0};