目录
一、数组
一组具有相同数据类型数据的有序集合
数组元素的类型称为该数组的基类型
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
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
