C++_系列自学课程_第_5_课_vector容器_《C++ Primer 第四版》

　　再一次遇到 vector 这个单词; 每一次见到这个单词都感觉这个单词非常的 "高大上"; 数字遇到vector马上就可以360度旋转；

当 "电" 遇到vector,马上让交流可以变得和直流一样进行控制（德国电气工程师的矢量控制理论，目前在工控界对电机控制应用

非常广泛，是变频器控制的基础理论，可惜的是中国目前没有这方面的真正的专家，就是IT行业中的TI公司的TMS320LF24xx系列

DSP做的事，中国的基础理论的研究真的是落后于西方发达国家很多年），而在C++中遇到这个单词，同样是高大上的感觉，马上

让我想起C语言中最复杂的部分指针；别说指针的操作你无所谓，就算你是C++、C#、Java的粉丝；没有指针，个人感觉就像没

有金箍棒的猴子，幻刺模糊直接让你子弹到处乱飞。

　　不瞎扯啦，开始今天的内容。

一、vector

1、作用

　　vector，从翻译对应的词语：容器，可以知道vector是用来装东西的罐子、坛子之类的东西；联系实际，坛坛罐罐可以用来装各

种不同的东西，可以用来盛酒，也可以用来放酸菜（南北朝鲜的酸菜就算啦），当然你如果是土豪的话，也可以用来放钢镚；如果你

是贪官的话，也可以用来藏你给情妇写的保证书什么的。

　　从C++的角度来看，vector可以用来存放不同类型的对象，例如可以把int类型的对象存放到容器里面，同样也可以将char类型的

对象存储到vector中，也可以将string对象存储到vector里面。

2、容器的定义

　　vector类型是C++标准库提供的一种类型，如果要在程序中引用这种类型，当然需要“报备”，如下所示：

#include <vector>  //引用相关的头文件
using std::vector;   //方便的使用std::命名空间/名字空间中的名字vector

　　报备完成后就可以名正言顺的经营啦；要使用 vector 必须指明容器里面存放的是什么类型的对象，就像在坛坛罐罐上面贴上标签

告诉别人里面存放的是什么；通过在 vector后面加上 <> 然后将对象类型写入到 <> 就可以啦，如下所示：

vector<int> vInt;

　　如上就定义了一个容器对象，并且这个容器是用来存储int类型的对象的。

　要点：尖括号里面指出的是容器中存放的是什么类型的对象；同时要注意的是 vector<int>是一种数据类型，

　 vector可以存储的对象不仅可以是内置类型，还可以是用户的自定义类型，例如string类。

vector<string>  vString;

　　同样 vector<string> 也是一种新的数据类型，这种数据类型的对象用来存储string对象。

3、容器的初始化

　　标准库提供的vector类型有多种初始化方式。

　　A: vector<T> v1; //容器对象v1保存类型为T的对象，容器类型的默认构造函数初始化对象v1为空

　这样定义的话，就是定义了一个容器，里面没有任何东西，就相当于一个空的坛子、罐子。

　　B: vector<T> v2(v1); //容器对象v2保存类型为T的对象，对象v2初始化为与v1一样的容器

　　这样定义的话，就表示开始的时候有一个罐子v1，然后又造了一个罐子v2，v2罐子是按照罐子v1为原型造的，如果v1里面有东西

那么v2罐子里面的东西与v1罐子一样；如果v1罐子里面没有东西，那么v2罐子里面也没有东西。

　　C: vector<T> v3(n, i); //容器v3保存类型为T的对象，对象初始化为保存n个类型为T、值为 i 的对象元素

　　这样定义的话，就表示下了一个明确订单，就是告诉你，你给我造一个罐子v3，里面放多少封(n)给情妇的保证书(i)。

　　D: vector<T> v4(n); //容器v4保存类型为T的对象，容器对象v4中初始化里面可以存放个数为n的T对象。

　　这样的定义的话，就是下了一个明确的订单，你给某个贪官造个罐子v4，这个罐子可以放多少(n)封给情妇的保证书，但是你不能

放保证书，放保证书的事情让贪官自己以后放。

Exp：

[[email protected]alhost cpp_src]# cat test.cpp
#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main()
{
    vector<int> vInt1;
    vector<int> vInt2(vInt1);
    vector<int> vInt3(3,4);
    vector<int> vInt4(5);

    string str("volcanol");
    vector<string> vStr1;
    vector<string> vStr2(vStr1);
    vector<string> vStr3(4,str);
    vector<string> vStr4(5);

    return 0;
}

　　这里需要注意的是，对于存储string对象容器，可以用字符串字面值进行初始化，如下所示：

vector<string>  str(4, "volcanol");

4、容器元素的值的初始化

　　一定要分辨清楚容器的初始化和容器元素的值的初始化两个概念，容器的初始化可以包括两个方面：容器本身的初始化

以及容器元素的值的初始化。

　　这里就细细的说一下这两个的不同之处。

　　A: vector<int> vInt; 这里对容器对象vInt进行初始化，初始化后知道对象vInt是一个空的对象，里面暂时不能存

放任何int对象，就是说这个坛子是一个实心的坛子，不能往里面塞东西。

　　B：vector<int> vInt1(2, 10); 这里不但对容器对象vInt1进行了初始化，同时还对容器对象里面的元素进行了初始化，

就是说容器里面存放了两个int类型的对象，且两个int对象的值均为10. 用坛坛罐罐来比喻就是罐子里面放了2个（初始化的是容器）

10元的钢镚（初始化的是容器里面的钢镚的大小）。

　　C: vector<int> vInt2(10); 这里对容器vInt2进行了初始化，而且在容器里面目前可以放10个int对象，而且这些int对象

的值为0。用坛坛罐罐来比喻的话就是罐子里面放了10个面值为0元的钢镚。

　　要点：

　　如果容器存放的对象类型为内置类型，且没有提供容器元素的初始化值，那么就会初始化容器的元素值为0.

例如：

　　　　vector<char> vCh(1); 那么容器vCh里面就有一个元素之为‘\0‘的的char对象。

　　如果容器存放的对象是类类型，且没有提供容器元素的初始化值，那么容器元素就会用类类型默认构造函数对容器的

元素进行初始化。

例如：

　　　　vector<string> vStr(2); 那么容器vStr里面就存放了两个值为空""字符串的string对象。

　　如果容器存放的对象是类类型，同时类类型没有默认构造函数，且没有提供元素的初始化值，那么标准库同样会产生

一个带初始值的对象，这个对象的每个成员都进行了初始化。（这个地方说的有点不明不白，我也是每天搞明白，有哪位大侠了

解的话，请不吝赐教）。

5、vector提供的操作

　　vector类提供了类似于string类的操作。

　　　　v.empty(); 检测对象v是否为空

　　　　v.size(); 返回对象v中的元素的个数

　　　　v.push_back(t); 往对象v中插入一个值为(t)新的元素，这个就是动态的增加容器对象的容量，

　　　　v[n]; 访问容器中的元素，相当于string对象的下标操作，而且容器对象下标操作符返回的是一个左值，可以进行写入操作。

　　　　v1 = v2; 容器的赋值操作，就是将容器对象v1的元素替换为v2中元素的副本，（这需要注意容器的大小）

　　　　v1 == v2；如果容器v1与v2相等，那么就返回true，这里包括容器本身以及容器中的元素，这个必须要注意。

　　　　 >, >=, != , <, <= 这些操作保持原本的意义。

Exp1：size() 和 empty()操作

[[email protected] cpp_src]# cat test.cpp
#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main()
{
    vector<int> vInt1;
    vector<int> vInt2(vInt1);
    vector<int> vInt3(3,4);
    vector<int> vInt4(5);

    cout<<"the size of vector<int> vInt1 is:"<<vInt1.size()<<endl;
    if(vInt1.empty())
        cout<<"vector<int> vInt1 is empty"<<endl;
    else
        cout<<"vector<int vInt1> is not empty"<<endl;

    return 0;
}

执行结果如下所示：

[[email protected] cpp_src]# g++ test.cpp
[[email protected] cpp_src]# ./a.out
the size of vector<int> vInt1 is:0
vector<int> vInt1 is empty

Exp: push_back()操作

[[email protected] cpp_src]# cat test.cpp
#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main()
{
    vector<int> vInt1;

    cout<<"the size of vector<int> vInt1 is:"<<vInt1.size()<<endl;
    if(vInt1.empty())
        cout<<"vector<int> vInt1 is empty"<<endl;
    else
        cout<<"vector<int vInt1> is not empty"<<endl;

    vInt1.push_back(1);
    cout<<"The size of vector<int> vInt1 is:"<<vInt1.size()<<endl;
    if(vInt1.empty())
        cout<<"vector<int> vInt1 is empty"<<endl;
    else
        cout<<"vector<int> vInt1 is not empty"<<endl;

    return 0;
}

执行结果如下：

[[email protected] cpp_src]# ./a.out
the size of vector<int> vInt1 is:0
vector<int> vInt1 is empty
The size of vector<int> vInt1 is:1
vector<int> vInt1 is not empty

　　可以发现执行 vInt1.push_back(1); 以后vInt的大小变成了1，而且不再是空的容器。

Exp：容器的下标操作

　　容器的下标操作返回的是容器里面的元素，这个要特别的注意。

[[email protected] cpp_src]# cat test.cpp
#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main()
{
    vector<int> vInt1;

    for(vector<int>::size_type i=0;i != 10; i++)
        vInt1.push_back(i);

    for(vector<int>::size_type i=0; i != vInt1.size(); i++)
        cout<<vInt1[i]<<endl;

    return 0;
}

执行结果如下：

[[email protected] cpp_src]# g++ test.cpp
[[email protected] cpp_src]# ./a.out
0
1
2
3
4
5
6
7
8
9

　　要点：容器的下标是从0开始计算的，其最大值为 v.size( ) - 1; 所以上面的第二个循环可以正常执行，

当i=9的时候， i != vInt1.size( )，因此可以进行循环；

　　　　　　而当i=10 的时候，i == vInt1.size(), for循环的条件不成立，因此跳出循环，不会产生下标越界。

　　vector<int>::size_type 类型为标准库为vector类型定义的表示vector大小的类型，在使用这个数据类型的

时候对象的类型 int 不能少，否则就会出错，这个地方经常会被遗忘。

Exp: 下标操作的赋值

[[email protected] cpp_src]# cat test.cpp
#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main()
{
    vector<int> vInt1(10);

    for(vector<int>::size_type i = 0; i != vInt1.size(); i++)
        vInt1[i]=i;

    for(vector<int>::size_type i=0; i != vInt1.size(); i++)
        cout<<vInt1[i]<<endl;

    cout<<"the size of vInt1 is: "<<vInt1.size()<<endl;
    return 0;
}

程序执行的结果是：

[[email protected] cpp_src]# ./a.out
0
1
2
3
4
5
6
7
8
9
the size of vInt1 is: 10

　　要点： vector下标操作返回的是容器里面存放的对象，是一个左值。

二、迭代器 iterator

　　C++标注库为访问vector提供了另外的一种机制，这个机制就是迭代器。

1、作用

　　迭代器的作用就是用来访问容器中的元素。

2、迭代器的定义

　　每一种类型的vector类型都定义了自己的迭代器类型，定义一个迭代器的语法如下所示：

　　　　vector<T>::iterator tIter;

　　这样就定义了一个用于容器类型为 vector<T>的迭代器对象 tIter； tIter的数据类型是 vector<T>::iterator,

在C++中可以通过迭代器来访问容器里面的元素。

　　默认定义通过上面的定义 tIter 将指向容器中的第一个元素，如果容器不为空的话。

　　迭代器的概念与C语言中的指针非常类似，都有一个指向的概念，但是要严格区分两者的区别。

3、迭代器的begin和end操作

　　每一种标准库定义的容器都定义了两个操作： begin() 和 end() 操作。 begin()操作返回的迭代器指向的容器中的

第一个元素，而end()操作则返回迭代器指向的容器中最后一个元素后面的一个位置，通常称为超出末端迭代器，表明指向了一个

不存在的元素； 如果容器为空，那么迭代器的begin() 和end()操作将指向同一个位置---超出末端迭代器的位置。

4、迭代器的解引用和自增操作

　　通过迭代器的解引用操作可以和下标操作符一样操作容器中的元素。

　　例如：

　　　　　　vector<int> vInt(3);

　　　　　　vector<int>::iterator iter=vInt.begin( ); //迭代器指向 vInt容器中的第一个元素，vInt容器中一共有3个元素。

　　　　　　*iter = 10; ====》相当于 vInt[0] = 10;

　　通过移动迭代器的指向，可以访问容器中不同的元素。可以通过自增运算符来移动迭代器的指向。　　

　　　　　　vector<int> vInt(3);

　　　　　　vector<int>::iterator iter=vInt.begin( ); //迭代器指向 vInt容器中的第一个元素，vInt容器中一共有3个元素。

　　　　　　*iter = 10; ====》相当于 vInt[0] = 10;

　　　　　 ++ iter ;

　　　　　　*iter = 5; =====>>相当于 vInt[1] = 5;

　　　　　　++ iter ;

　　　　　　*iter = 1 ; =====>>相当于 vInt[2] = 1;

　　　　　　　iter = vInt.begin(); =====》相当于将迭代器再次指向容器中的第一个元素，

　　　　　　 * iter = 3 ; ======》相当于vInt[0] = 3;

Exp:

[[email protected] cpp_src]# cat test.cpp
#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main()
{
    vector<string> vStr(3);

    vector<string>::iterator iter=vStr.begin();

    while(iter != vStr.end())
    {
        cin>>*iter;
        ++iter;
    }

    iter=vStr.begin();
    while(iter != vStr.end())
    {
        cout<<*iter<<endl;
        ++iter;
    }

    return 0;
}

程序执行结果如下：

[[email protected] cpp_src]# ./a.out
abd 121 456
abd
121
456

再次执行结果如下：

[[email protected] cpp_src]# ./a.out
volcanol hello world  hi
volcanol
hello
world

5、迭代器的比较操作

　　可以测试两个迭代器是否指向容器中的同一个元素，测试用的操作符为：== 和 != 。

exp:

[[email protected] cpp_src]# cat test.cpp
#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main()
{
    vector<string> vStr(3);

    vector<string>::iterator iter1=vStr.begin();
    vector<string>::iterator iter2=vStr.end();

    if(iter1 == iter2)
        cout<<"iter1 and iter2 point to the same element"<<endl;
    else
        cout<<"iter1 and iter2 don‘t point to the same element "<<endl;

    ++iter1;
    ++iter1;
    ++iter1;

    cout<<"after iter1 moved:";
    if(iter1 != iter2)
        cout<<"iter1 and iter2 don‘t point to the same element"<<endl;
    else
        cout<<"iter1 and iter2 point to the same element"<<endl;

    return 0;
}

程序执行结果为：

[[email protected] cpp_src]# ./a.out
iter1 and iter2 don‘t point to the same element
after iter1 moved:iter1 and iter2 point to the same element

6、利用迭代器循环遍历容器中的元素

　　前面我们利用下标操作符和 v.size()操作遍历了整个容器的元素，现在我们利用迭代器遍历容器。

[[email protected] cpp_src]# cat test.cpp
#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main()
{
    vector<string> vStr(3);
    vector<string>::iterator iter=vStr.begin();

    for(vector<string>::size_type i=0; i !=vStr.size();i++)
    {
        cin>>vStr[i];
    }

    while(iter != vStr.end())
    {
        cout<<*iter<<endl;
        ++iter;
    }

    return 0;
}

执行结果如如下所示：

[[email protected]host cpp_src]# g++ test.cpp
[[email protected] cpp_src]# ./a.out
kiki gaida volcanol hi world
kiki
gaida
volcanol

7、const_iterator 和 const vector<T>::iterator

看到这个题头，就会想起C语言中指针和const的结合。

　 const_iterator的迭代器不能用来改变容器中元素的值，而 const vector<T>::iteraor则不能改变指向。

例如：

　　vector<int> vInt(3, 10);

　　vector<int>::const_iterator iter1= vInt.begin();

　　*iter1 = 5 ; //错误，不能通过const_iterator迭代器改变容器中元素的值。

　　++iter; //正确，可以改变迭代器的指向。

而下面的情形是：

　　vector<string> vStr(3,"hi");

　　const vector<string>::iterator iter2=vStr.begin();

　　*iter2 = "volcanol"; //正确，可以通过迭代器的解引用操作符来操作容器中的元素。

　　iter2 =vStr.end() ; //错误， const 迭代器的指向不能改变。

而下面的情形是：

　　const vector<int> vInt(5,1);

vector<int>::iterator iter=vInt.begin(); //错误，不能这样定义

exp：

 1 #include <iostream>
 2 #include <string>
 3 #include <vector>
 4
 5 using std::cin;
 6 using std::cout;
 7 using std::endl;
 8 using std::string;
 9 using std::vector;
10
11 int main()
12 {
13     const vector<int> vInt(3); //ok,vInt[i]=0;
14     cout<<vInt[0]<<endl;
15
16     vector<int>::iterator iter=vInt.begin();
17     *iter = 10;
18     cout<<vInt[0]<<endl;
19
20     return 0;
21 }

编译的时候提示：

[[email protected] cpp_src]# g++ test.cpp
test.cpp: In function ‘int main()’:
test.cpp:16: 错误：请求从 ‘__gnu_cxx::__normal_iterator<const int*, std::vector<int, std::allocator<int> > >’ 转换到非标量类型 ‘__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >’

　　提示16行错误。

而下面的情形是：

　　vector<int> vInt(10,1);

　　const vector<int>::const_iterator iter=vInt.begin(); //正确，这样可以定义

这个地方需要注意，第一个const指出的是 iter的指向不能改变，第二个const_iterator 指出不能通过 *iter 改变容器中

元素的值。

要点：

　　const修饰时迭代器和类型和容器内元素的类型要一致，如果元素不可改变，那么就不能定义可以改变容器元素的迭代器来

访问容器中的元素。

8、迭代器支持算术运算

　　可以给迭代器进行 +n 和-n 的操作，就和C语言中的指针的加法、减法运算类似。

[[email protected] cpp_src]# cat test.cpp
#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main()
{
    vector<int> vInt(10);
    vector<int>::iterator iter=vInt.begin();

    for(;iter != vInt.end(); ++iter)
        cin>>*iter;

    iter=vInt.begin();
    iter = iter + vInt.size()/2;
    cout<<*iter<<endl;

    iter = iter - 2;
    cout<<*iter<<endl;

    return 0;
}

执行结果如下所示：

[[email protected] cpp_src]# g++ test.cpp
[[email protected] cpp_src]# ./a.out
1 2 3 4 5 6 7 8 9 10 11
6
4

　　今天关于vector和迭代器就描述到这里，后续内容，未完待续..........................

时间： 2024-10-23 10:33:59

C++_系列自学课程_第_5_课_vector容器_《C++ Primer 第四版》的相关文章

C++_系列自学课程_第_7_课_数组_《C++ Primer 第四版》

说到数组,大家应该都很熟悉,在C.Pascal.Java等语言中,都有数组的概念.在C++中也提供了对数组的支持.数组简单来说就是一堆相同数据类型对象的集合. 这里要把握住两个要点: 相同的数据类型.集合. 一.数组 1.定义数组是由数组存储的对象的类型名.标识符和数组维数组成一种复合数据类型. 类型名规定了可以存储在数组中的对象的类型, 标识符用来标识数组,用来在程序中引用数组元素, 维数用来规定数组可以存放多少数组元素. 数组的定义如下所示: 类型名数组标识符[n]; 下面是一些数组

C++_系列自学课程_第_6_课_bitset集_《C++ Primer 第四版》

在C语言中要对一个整数的某一个位进行操作需要用到很多的技巧.这种情况在C++里面通过标准库提供的一个抽象数据类型 bitset得到了改善. 一.标准库bitset类型 1.bitset的作用 bitset可以看成bit的集合,可以单独的访问集合中的某一位,访问的结果可以作为逻辑的判断的条件.使用bitset的时候可以不关心这些bit的存储方式,而通过bitset类型提供的一套接口进行操作. 和string和vector一样,要使用bitset类型,需要报备,如下所示: #include <bi

C++_系列自学课程_第_3_课_变量和基本类型_《C++ Primer 第四版》

最近复习C++相关内容,决定在这里记录自己复习的过程. 以前写过部分文字,但是没有坚持连续写,因此学完后基本又忘光啦,主要是没有实践,这一次决定自学完后,在这里在复习一遍增强自己的记忆和理解程度. 一.基本内置类型 C++语言内置了一些数据类型,主要有两大类: 整型和浮点型. 整型又有: bool型.char型.wchar_t型.short型,int型,long int型. 浮点型有: float型, double型.long double型(扩展双精度型). 我们知道不同的数据类型决定了不

C++_系列自学课程_第_8_课_指针和引用_《C++ Primer 第四版》

C语言最富有迷幻色彩的部分当属指针部分,无论是指针的定义还是指针的意义都可算是C语言中最复杂的内容.指针不但提供给了程序员直接操作硬件部分的操作接口,还提供给了程序员更多灵活的用法.C++继承这一高效的机制,同时引入了另一个与指针相似但不相同的机制: 引用. 一.引用简单的来说,引用就是变量的别名(alias), 通过别名我们可以操作引用代表的变量. 定义一个引用的语法如下所示: 变量类型 &引用标识符 = 变量名. Exp: int iVar=10; int &iRef = iVa

C++_系列自学课程_第_4_课_string_《C++ Primer 第四版》

相信学习过计算机编程的人,基本应该都接触过C语言,在C语言中处理字符串大家一定多遇到过, 也都知道处理字符串非常麻烦,而在C++里面,由标准库string类提供对可变长的字符串的支持.下面来看看string类的特性. 1.使用的先决条件在使用标准库之前必须包含相应的头文件, 要使用string类型,就需要包含相应的头文件,如下所示: #include <string> 在使用iostream的时候,我们未来引用iostream里面的类,前面需要加上 std:: 来表示引用的是标准 IO

C++_系列自学课程_第_11_课_类型转换_《C++ Primer 第四版》

上次说了关于表达式的一些内容,说到还有一些关于数据类型转换的内容,今天我们接着八一八C++中的数据类型转换. 一.隐式类型转换在表达式中,有些操作符可以对多种类型的操作数进行操作, 例如 + 操作符的操作数可以同时有int型,也可以有float型, 这就引入了一个问题到底应该由什么决定表达式的值的类型. 例如: 3.1415926 + 5; //double类型 + 整型, 结果为什么类型呢?? 3.1415926 * 2 * 3 ; //double类型 * 整型 * 整型: 得到的表达式

C++_系列自学课程_第_10_课_表达式_《C++ Primer 第四版》

程序设计语言中大部分程序都在进行表达式的求值操作, 例如求两个数的和,求一个表达式的逻辑结果,或者通过输入输出表达式语句进行输入和输出. 这里我们对表达式进行讨论. 一.表达式 1.表达式表达式由一个操作数或者多个操作数同操作符组合而成: 字面值是一个最简单的表达式. 表达式都会产生一个结果,如果表达式中没有操作符,则表达式的值是操作数本身, 如果表达式中有操作符,则表达式的结果是操作符对操作数进行操作后的结果. 一般而言表达式的返回的是右值,不能给表达式赋值, 但可以获取表达式的值. E

C++_系列自学课程_第_12_课_语句_《C++ Primer 第四版》

前面的文章说完了表达式和类型转换的部分内容,在我参考的书里面,接下来讨论的是各种语句,包括:顺序语句.声明语句.复合语句(块语句).语句作用域 .if语句.while语句.for语句.do...while语句.break语句.continue语句.goto语句.try语句. 这里我们来讨论这些语句,为了方便讨论和记忆,我们可以将这些语句可以分为五大类: 简单语句.条件语句.循环语句.流程控制语句.异常处理.当然也可以不这么分类,我这么说就是为了自己好理解和记忆. 一.简单语句我将顺序语句

C++_系列自学课程_第_12_课_结构体

1 #include <iostream> 2 #include <string> 3 4 using namespace std; 5 6 struct CDAccount 7 { 8 double balance; //余额 9 double rate; //利息 10 int term; //存期 11 }; 12 13 struct Date 14 { 15 int year; 16 int month; 17 int day; 18 }; 19 20 struct Per