上一节学习了C++的函数：c++：-2，本节学习C++的数组、指针和字符串

数组

定义和初始化

定义



例如：int a[10];

表示a为整型数组，有10个元素：a[0]...a[9]

例如: int a[5][3];

表示a为整型二维数组，其中第一维有5个下标（04），第二维有3个下标（02），数组的元素个数为15，可以用于存放5行3列的整型数据表格。

使用

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

例如：a[0]=a[5]+a[7]-a[2*3]

例如：b[1][2]=a[2][3]/2

存储

（1）一维数组的存储

数组元素在内存中顺次存放，它们的地址是连续的。元素间物理地址上的相邻，对应着逻辑次序上的相邻。



（2）二维数组的存储

按行存放

例如： float a[3][4];

可以理解为：



其中数组a的存储顺序为：

\[a00,a01,a02,a03,a10,a11,a12,a13,a20,a21,a22,a23
\]

初始化

（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)二维数组的初始化

  • 将所有初值写在一个{}内，按顺序初始化

    例如：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}};
  • 列出全部初始值时，第1维下标个数可以省略

    例如：static int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12};

    或：static int a[][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
  • 注意：

    如果不作任何初始化，内部auto型数组中会存在垃圾数据，static数组中的数据默认初始化为0；

    如果只对部分元素初始化，剩下的未显式初始化的元素，将自动被初始化为零；

传参

  • 数组元素作实参，与单个变量一样。
  • 数组名作参数，形、实参数都应是数组名（实质上是地址），类型要一样，传送的是数组首地址。
  • 对形参数组的改变会直接影响到实参数组。

对象数组

定义和访问

（1）定义对象数组

类名 数组名[元素个数]；

（2）访问对象数组元素

通过下标访问：数组名[下标].成员名

初始化

  • 数组中每一个元素对象被创建时，系统都会调用类构造函数初始化该对象。
  • 通过初始化列表赋值。

    例：Point a[2]={Point(1,2),Point(3,4)};
  • 如果没有为数组元素指定显式初始值，数组元素便使用默认值初始化（调用默认构造函数）。
  • 元素所属的类不声明构造函数，则采用默认构造函数。
  • 各元素对象的初值要求为相同的值时，可以声明具有默认形参值的构造函数。
  • 各元素对象的初值要求为不同的值时，需要声明带形参的构造函数。
  • 当数组中每一个对象被删除时，系统都要调用一次析构函数。

基于范围的for循环

原for循环

  1. #include "iostream"
  3. using namespace std;
  4. int main() {
  5.     int array[3] = {1, 2, 3};
  6.     int *p;
  7.     for (p = array; p < array + sizeof(array) / sizeof(int); ++p) {
  8.         *p += 2;
  9.         std::cout << *p << std::endl;
  10.     }
  11. }

新for循环

  1. #include "iostream"
  3. using namespace std;
  4. int main() {
  5.     int array[3] = {1, 2, 3};
  6.     for(int & e : array)
  7.     {
  8.         e += 2;
  9.         std::cout<<e<<std::endl;
  10.     }
  11.     return 0;
  12. }

指针

（1）内存空间的访问方式

  • 通过变量名访问
  • 通过地址访问

（2）指针的概念

  • 指针：内存地址，用于间接访问内存单元
  • 指针变量：用于存放地址的变量

定义

（1）例：

static int i;

static int* ptr = &i;

（2）例：

*ptr = 3;

（3）与地址相关的运算——“*”和“&”

  • 指针运算符：*
  • 地址运算符：&

初始化

（1）语法形式：存储类型 数据类型 *指针名＝初始地址；

例：int *pa = &a;

（2）注意事项

  • 用变量地址作为初值时，该变量必须在指针初始化之前已声明过，且变量类型应与指针类型一致。
  • 可以用一个已有合法值的指针去初始化另一个指针变量。
  • 不要用一个内部非静态变量去初始化 static 指针。

赋值

（1）语法形式：指针名=地址

注意：“地址”中存放的数据类型与指针类型必须相符

（2）向指针变量赋的值必须是地址常量或变量，不能是普通整数。例如：

  • 通过地址运算“&”求得已定义的变量和对象的起始地址
  • 动态内存分配成功时返回的地址

（3）例外：整数0可以赋给指针，表示空指针。

（4）允许定义或声明指向 void 类型的指针。该指针可以被赋予任何类型对象的地址。

例： void *general;

指针空值nullptr

（1）以往用0或者NULL去表达空指针的问题：

C/C++的NULL宏是个被有很多潜在BUG的宏。因为有的库把其定义成整数0，有的定义成 (void*)0。在C的时代还好。但是在C++的时代，这就会引发很多问题。

（2）C++11使用nullptr关键字，是表达更准确，类型安全的空指针

指向常量的指针

不能通过指向常量的指针改变所指对象的值，但指针本身可以改变，可以指向另外的对象。

例：

  1. int a;
  2. const int *p1 = &a; //p1是指向常量的指针
  3. int b;
  4. p1 = &b; //正确，p1本身的值可以改变
  5. *p1 = 1; //编译时出错，不能通过p1改变所指的对象(常量)

指针类型的常量

若声明指针常量，则指针本身的值不能被改变。

例：

  1. int a;
  2. int * const p2 = &a;
  3. p2 = &b; //错误，p2是指针常量，不能改变

运算

算术运算

  • 指针p加上或减去n

    其意义是指针当前指向位置的前方或后方第n个数据的起始位置。
  • 指针的++、--运算

    意义是指向下一个或前一个完整数据的起始。
  • 运算的结果值取决于指针指向的数据类型，总是指向一个完整数据的起始位置。
  • 当指针指向连续存储的同类型数据时，指针与整数的加减运和自增自减算才有意义。

    （1）指针与整数相加的意义

关系运算

  • 指向相同类型数据的指针之间可以进行各种关系运算。
  • 指向不同数据类型的指针，以及指针与一般整数变量之间的关系运算是无意义的。
  • 指针可以和零之间进行等于或不等于的关系运算。

    例如：p==0或p!=0

指针与数组

用指针访问数组

数组是一组连续存储的同类型数据，可以通过指针的算术运算，使指针依次指向数组的各个元素，进而可以遍历数组。

（1）定义与赋值：

例：int a[10], pa;

pa=&a[0]; 或 pa=a;

经过上述定义及赋值后：

pa就是a[0]，(pa+1)就是a[1]，... ，(pa+i)就是a[i]。a[i], *(pa+i), *(a+i), pa[i]都是等效的。

（2）注意：

不能写 a++，因为a是数组首地址、是常量。

（3）举例：

设有一个int型数组a，有10个元素。用三种方法输出各元素：

方法1：使用数组名和下标

  1. #include "iostream"
  2. using namespace std;
  3. int main() {
  4.     int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
  5.     for (int i = 0; i < 10; i++)
  6.         cout << a[i] << "  ";
  7.     cout << endl;
  8.     return 0;
  9. }

方法2：使用数组名和指针运算

  1. #include "iostream"
  2. using namespace std;
  3. int main() {
  4.     int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
  5.     for (int i = 0; i < 10; i++)
  6.         cout << *(a+i) << "  ";
  7.     cout << endl;
  8.     return 0;
  9. }

方法3：使用指针变量

  1. #include "iostream"
  2. using namespace std;
  3. int main() {
  4.     int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
  5.     for (int *p = a; p < (a + 10); p++)
  6.         cout << *p << "  ";
  7.     cout << endl;
  8.     return 0;
  9. }

指针与函数

以指针作为函数参数

为什么需要用指针做参数？

  • 需要数据双向传递时（引用也可以达到此效果）
  • 用指针作为函数的参数，可以使被调函数通过形参指针存取主调函数中实参指针指向的数据，实现数据的双向传递
  • 需要传递一组数据，只传首地址运行效率比较高
  • 实参是数组名时形参可以是指针

指针类型的函数



（1）不要将非静态局部地址用作函数的返回值



（2）例子

  1. #include "iostream"
  2. using namespace std;
  4. int *search(int *a,int num)
  5. {
  6.     for(int i=0;i<10;i++)
  7.     {
  8.         if(a[i]==0)
  9.             return &a[i];
  10.     }
  11. }
  13. int main()
  14. {
  15.     int arr[10];
  16.     int *search(int *a,int num);
  17.     for(int i=0;i<10;i++){
  18.         cin >> arr[i];
  19.     }
  20.     int *zeroptr= search(arr,10);
  21.     return 0;
  22. }

指向函数的指针

（1）定义形式

存储类型 数据类型 (*函数指针名)();

（2）含义

函数指针指向的是程序代码存储区。

（3）用途

实现函数回调

  • 通过函数指针调用的函数
  • 例如将函数的指针作为参数传递给一个函数，使得在处理相似事件的时候可以灵活的使用不同的方法。

    调用者不关心谁是被调用者
  • 需知道存在一个具有特定原型和限制条件的被调用函数。

对象指针

（1）定义

类名 *对象指针名；

（2）例

  1. Point a(5,10);
  2. Piont *ptr;
  3. ptr=&a;

（3）通过指针访问对象成员

对象指针名->成员名

例：ptr->getx() 相当于** (*ptr).getx();**

（4）举例

  1. #include <iostream>
  2. using namespace std;
  4. class Point {
  5. public:
  6.     Point(int x = 0, int y = 0) : x(x), y(y) { }
  7.     int getX() const { return x; }
  8.     int getY() const { return y; }
  9. private:
  10.     int x, y;
  11. };
  12. int main() {
  13.     Point a(4, 5);
  14.     Point *p1 = &a; //定义对象指针，用a的地址初始化
  15.     cout << p1->getX() << endl;//用指针访问对象成员
  16.     cout << a.getX() << endl; //用对象名访问对象成员
  17.     return 0;
  18. }
  19. 输出：
  20. 4
  21. 4

this指针

  • 指向当前对象自己
  • 隐含于类的每一个非静态成员函数中
  • 指出成员函数所操作的对象

    当通过一个对象调用成员函数时，系统先将该对象的地址赋给this指针，然后调用成员函数，成员函数对对象的数据成员进行操作时，就隐含使用了this指针。
  • 例如：Point类的getX函数中的语句：return x;

    相当于： return this->x;
  • 例
  1. class Fred; //前向引用声明
  2. class Barney {
  3.     Fred *x;
  4. };
  5. class Fred {
  6.     Barney y;
  7. };

动态内存分配

分配与释放

（1）动态申请内存操作符 new

new 类型名T（初始化参数列表）

功能：在程序执行期间，申请用于存放T类型对象的内存空间，并依初值列表赋以初值。

结果值：成功：T类型的指针，指向新分配的内存；失败：抛出异常。

（2）释放内存操作符delete

delete 指针p

功能：释放指针p所指向的内存。p必须是new操作的返回值。

（3）举例

  1. #include <iostream>
  2. using namespace std;
  4. class Point {
  5. public:
  6.     Point() : x(0), y(0) {
  7.         cout<<"Default Constructor called."<<endl;
  8.     }
  9.     Point(int x, int y) : x(x), y(y) {
  10.         cout<< "Constructor called."<<endl;
  11.     }
  12.     ~Point() { cout<<"Destructor called."<<endl; }
  13.     int getX() const { return x; }
  14.     int getY() const { return y; }
  15.     void move(int newX, int newY) {
  16.         x = newX;
  17.         y = newY;
  18.     }
  19. private:
  20.     int x, y;
  21. };
  23. int main() {
  24.     cout << "Step one: " << endl;
  25.     Point *ptr1 = new Point; //调用默认构造函数
  26.     delete ptr1; //删除对象，自动调用析构函数
  27.     cout << "Step two: " << endl;
  28.     ptr1 = new Point(1,2);
  29.     delete ptr1;
  30.     return 0;
  31. }
  32. 输出：
  33. Step one:
  34. Default Constructor called.
  35. Destructor called.
  36. Step two:
  37. Constructor called.
  38. Destructor called.

动态数组



动态多维数组





智能指针

  • 显式管理内存在是能上有优势，但容易出错。
  • C++11提供智能指针的数据类型，对垃圾回收技术提供了一些支持，实现一定程度的内存管理
  • 三类：

    unique_ptr ：不允许多个指针共享资源，可以用标准库中的move函数转移指针

    shared_ptr ：多个指针共享资源

    weak_ptr ：可复制shared_ptr，但其构造或者释放对资源不产生影响

vector对象

（1）为什么需要vector？

封装任何类型的动态数组，自动创建和删除。

数组下标越界检查。

（2）vector对象的定义

vector<元素类型> 数组对象名(数组长度);

（3）例：

  1. vector<int> arr(5)//建立大小为5的int数组

vector对象的使用

（1）对数组元素的引用

与普通数组具有相同形式：vector对象名 [ 下标表达式 ]

（2）vector数组对象名不表示数组首地址

获得数组长度用size函数：数组对象名.size()

（3）举例：

  1. #include <iostream>
  2. #include <vector>
  3. using namespace std;
  5. //计算数组arr中元素的平均值
  6. double average(const vector<double> &arr) //vector的引用
  7. {
  8.     double sum = 0;
  9.     for (unsigned i = 0; i<arr.size(); i++)
  10.         sum += arr[i];
  11.     return sum / arr.size();
  12. }
  13. int main() {
  14.     unsigned n;
  15.     cout << "n = ";
  16.     cin >> n;
  17.     vector<double> arr(n); //创建数组对象
  18.     cout << "Please input " << n << " real numbers:" << endl;
  19.     for (unsigned i = 0; i < n; i++)
  20.         cin >> arr[i];
  21.     cout << "Average = " << average(arr) << endl;
  22.     return 0;
  23. }
  24. 输出：
  25. n = 5
  26. Please input 5 real numbers:
  27. 1
  28. 2
  29. 3
  30. 4
  31. 6
  32. Average = 3.2

深拷贝

浅层复制

实现对象间数据元素的一一对应复制。

举例：

  1. #include <iostream>
  2. #include <cassert>
  3. using namespace std;
  5. class Point {
  6. //类的声明同例6-16
  7. //……
  8. };
  9. class ArrayOfPoints {
  10. //类的声明同例6-18
  11. //……
  12. };
  14. int main() {
  15.     int count;
  16.     cout << "Please enter the count of points: ";
  17.     cin >> count;
  18.     ArrayOfPoints pointsArray1(count); //创建对象数组
  19.     pointsArray1.element(0).move(5,10);
  20.     pointsArray1.element(1).move(15,20);
  21.     ArrayOfPoints pointsArray2(pointsArray1); //创建副本
  22.     cout << "Copy of pointsArray1:" << endl;
  23.     cout << "Point_0 of array2: " << pointsArray2.element(0).getX() << ", "
  24.          << pointsArray2.element(0).getY() << endl;
  25.     cout << "Point_1 of array2: " << pointsArray2.element(1).getX() << ", "
  26.          << pointsArray2.element(1).getY() << endl;
  27.     pointsArray1.element(0).move(25, 30);
  28.     pointsArray1.element(1).move(35, 40);
  29.     cout<<"After the moving of pointsArray1:"<<endl;
  30.     cout << "Point_0 of array2: " << pointsArray2.element(0).getX() << ", "
  31.          << pointsArray2.element(0).getY() << endl;
  32.     cout << "Point_1 of array2: " << pointsArray2.element(1).getX() << ", "
  33.          << pointsArray2.element(1).getY() << endl;
  34.     return 0;
  35. }
  36. 运行结果如下：
  37. Please enter the number of points:2
  38. Default Constructor called.
  39. Default Constructor called.
  40. Copy of pointsArray1:
  41. Point_0 of array2: 5, 10
  42. Point_1 of array2: 15, 20
  43. After the moving of pointsArray1:
  44. Point_0 of array2: 25, 30
  45. Point_1 of array2: 35, 40
  46. Deleting...
  47. Destructor called.
  48. Destructor called.
  49. Deleting...
  50. 接下来程序出现运行错误。

深层复制

当被复制的对象数据成员是指针类型时，不是复制该指针成员本身，而是将指针所指对象进行复制。

当返回的对象含有动态创建的空间时，需要用深层复制

  1. #include <iostream>
  2. #include <cassert>
  3. using namespace std;
  5. class Point { //类的声明同例6-16
  6. };
  7. class ArrayOfPoints {
  8. public:
  9.     ArrayOfPoints(const ArrayOfPoints& pointsArray);
  10. //其他成员同例6-18
  11. };
  12. ArrayOfPoints::ArrayOfPoints(const ArrayOfPoints& v) {
  13.     size = v.size;
  14.     points = new Point[size];//重新创建空间
  15.     for (int i = 0; i < size; i++)
  16.         points[i] = v.points[i];
  17. }
  18. int main() {
  19. //同例6-20
  20. }
  21. 程序的运行结果如下：
  22. Please enter the number of points:2
  23. Default Constructor called.
  24. Default Constructor called.
  25. Default Constructor called.
  26. Default Constructor called.
  27. Copy of pointsArray1:
  28. Point_0 of array2: 5, 10
  29. Point_1 of array2: 15, 20
  30. After the moving of pointsArray1:
  31. Point_0 of array2: 5, 10
  32. Point_1 of array2: 15, 20
  33. Deleting...
  34. Destructor called.
  35. Destructor called.
  36. Deleting...
  37. Destructor called.
  38. Destructor called.

移动构造函数

在现实中有很多这样的例子，我们将钱从一个账号转移到另一个账号，将手机SIM卡转移到另一台手机，将文件从一个位置剪切到另一个位置……移动构造可以减少不必要的复制，带来性能上的提升。

  • C++11标准中提供了一种新的构造方法——移动构造。
  • C++11之前，如果要将源对象的状态转移到目标对象只能通过复制。在某些情况下，我们没有必要复制对象——只需要移动它们。
  • C++11引入移动语义：源对象资源的控制权全部交给目标对象

问题

当临时对象在被复制后，就不再被利用了。我们完全可以把临时对象的资源直接移动，这样就避免了多余的复制操作。

移动构造

什么时候该触发移动构造？

有可被利用的临时对象

移动构造函数:class_name ( class_name && )

字符串

字符数组

  • 字符串常量

    例："program"
  • 各字符连续、顺序存放，每个字符占一个字节，以‘\0’结尾，相当于一个隐含创建的字符常量数组
  • “program”出现在表达式中，表示这一char数组的首地址
  • 首地址可以赋给char常量指针：

    const char *STRING1 = "program";

缺点

  • 执行连接、拷贝、比较等操作，都需要显式调用库函数，很麻烦
  • 当字符串长度很不确定时，需要用new动态创建字符数组，最后要用delete释放，很繁琐
  • 字符串实际长度大于为它分配的空间时，会产生数组下标越界的错误

string

使用字符串类string表示字符串

string实际上是对字符数组操作的封装

构造函数

（1）string(); //默认构造函数，建立一个长度为0的串

例：

string s1;

（2）string(const char *s); //用指针s所指向的字符串常量初始化string对象

例：

string s2 = “abc”;

（3）string(const string& rhs); //复制构造函数

例：

string s3 = s2;

常用操作

  • 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的字符

例：

  1. string s1 = "abc", s2 = "def";
  2. string s3 = s1 + s2; //结果是"abcdef"
  3. bool s4 = (s1 < s2); //结果是true
  4. char s5 = s2[1]; //结果是'e'

getline

如何输入整行字符串？

用cin的>>操作符输入字符串，会以空格作为分隔符，空格后的内容会在下一回输入时被读取

  • getline可以输入整行字符串（要包string头文件），例如：getline(cin, s2);
  • 输入字符串时，可以使用其它分隔符作为字符串结束的标志（例如逗号、分号），将分隔符作为getline的第3个参数即可，例如：getline(cin, s2, ',');

程序

数组

存放数组

求Fibonacci数列的前20项

  1. #include <iostream>
  2. using namespace std;
  4. int main() {
  5.     int i;
  6.     int f[20] = {1,1}; //初始化第0、1个数
  7.     for (i = 2; i < 20; i++) //求第2～19个数
  8.         f[i] = f[i - 2] + f[i - 1];
  9.     for (i=0;i<20;i++) { //输出，每行5个数
  10.         if (i % 5 == 0) cout << endl;
  11.         cout.width(12); //设置输出宽度为12
  12.         cout << f[i];
  13.     }
  14.     return 0;
  15. }
  16. 输出：
  17.            1           1           2           3           5
  18.            8          13          21          34          55
  19.           89         144         233         377         610
  20.          987        1597        2584        4181        6765

统计正确率

循环从键盘读入若干组选择题答案，计算并输出每组答案的正确率，直到输入ctrl+z为止。每组连续输入5个答案，每个答案可以是'a','b','c','d'。

  1. #include <iostream>
  2. using namespace std;
  4. int main() {
  5.     const char key[ ] = {'a','c','b','a','d'};
  6.     const int NUM_QUES = 5;
  7.     char c;
  8.     int ques = 0, numCorrect = 0;
  9.     cout << "Enter the " << NUM_QUES << " question tests:" << endl;
  10.     while(cin.get(c)) //cin.get(c)得到的是输出流，所以只需要一次输入
  11.     {
  12.         if(c != '\n') {
  13.             if(c == key[ques]) {
  14.                 numCorrect++; cout << " ";
  15.             } else
  16.                 cout<<"*";
  17.             ques++;
  18.         } else {
  19.             cout << " Score " << static_cast<float>(numCorrect)/NUM_QUES*100 << "%";
  20.             ques = 0;  numCorrect = 0; cout << endl;
  21.         }
  22.     }
  23.     return 0;
  24. }
  25. 输出：
  26. Enter the 5 question tests:
  27. abcda
  28.  **** Score 20%
  29. abcad
  30.  **   Score 60%
  31. cabcd
  32. ** *  Score 40%
  33. ddaca
  34. ***** Score 0%

使用数组名作为函数参数

主函数中初始化一个二维数组，表示一个矩阵，矩阵，并将每个元素都输出，然后调用子函数，分别计算每一行的元素之和，将和直接存放在每行的第一个元素中，返回主函数之后输出各行元素的和。

  1. #include <iostream>
  2. using namespace std;
  4. void rowSum(int a[][4], int nRow) {
  5.     for (int i = 0; i < nRow; i++) {
  6.         for(int j = 1; j < 4; j++)
  7.             a[i][0] += a[i][j];
  8.     }
  9. }
  10. int main() {   //主函数
  11.     //定义并初始化数组
  12.     int table[3][4] = {{1, 2, 3, 4}, {2, 3, 4, 5}, {3, 4, 5, 6}};
  13.     //输出数组元素
  14.     for (int i = 0; i < 3; i++)  {
  15.         for (int j = 0; j < 4; j++)
  16.             cout << table[i][j] << "   ";
  17.         cout << endl;
  18.     }
  19.     rowSum(table, 3);  //调用子函数，传入的是数组名，计算各行和
  20.     //输出计算结果
  21.     for (int i = 0; i < 3; i++)
  22.         cout << "Sum of row " << i << " is " << table[i][0] << endl;
  23.     return 0;
  24. }
  25. 输出：
  26. 1   2   3   4
  27. 2   3   4   5
  28. 3   4   5   6
  29. Sum of row 0 is 10
  30. Sum of row 1 is 14
  31. Sum of row 2 is 18

对象数组应用

  1. //Point.h
  2. #ifndef _POINT_H
  3. #define _POINT_H
  4. class Point { //类的定义
  5. public: //外部接口
  6.     Point();
  7.     Point(int x, int y);
  8.     ~Point();
  9.     void move(int newX,int newY);
  10.     int getX() const { return x; }
  11.     int getY() const { return y; }
  12.     static void showCount(); //静态函数成员
  13. private: //私有数据成员
  14.     int x, y;
  15. };
  16. #endif //_POINT_H
  18. //Point.cpp
  19. #include <iostream>
  20. #include "Point.h"
  21. using namespace std;
  22. Point::Point() : x(0), y(0) {
  23.     cout << "Default Constructor called." << endl;
  24. }
  25. Point::Point(int x, int y) : x(x), y(y) {
  26.     cout << "Constructor called." << endl;
  27. }
  28. Point::~Point() {
  29.     cout << "Destructor called." << endl;
  30. }
  31. void Point::move(int newX,int newY) {
  32.     cout << "Moving the point to (" << newX << ", " << newY << ")" << endl;
  33.     x = newX;
  34.     y = newY;
  35. }
  37. #include "Point.h"
  38. #include <iostream>
  39. using namespace std;
  40. int main() {
  41.     cout << "Entering main..." << endl;
  42.     Point a[2];
  43.     for(int i = 0; i < 2; i++)
  44.         a[i].move(i + 10, i + 20);
  45.     cout << "Exiting main..." << endl;
  46.     return 0;
  47. }
  48. 输出：
  49. Entering main...
  50. Default Constructor called.
  51. Default Constructor called.
  52. Moving the point to (10, 20)
  53. Moving the point to (11, 21)
  54. Exiting main...
  55. Destructor called.
  56. Destructor called.

指针

void指针

  1. #include <iostream>
  2. using namespace std;
  4. int main() {
  5. //!void voidObject; 错，不能声明void类型的变量
  6.     void *pv; //对，可以声明void类型的指针
  7.     int i = 5;
  8.     pv = &i; //void类型指针指向整型变量
  9.     int *pint = static_cast<int *>(pv); //void指针转换为int指针
  10.     cout << "*pint = " << *pint << endl;
  11.     return 0;
  12. }
  13. 输出：
  14. *pint = 5

指针表示矩阵

  1. #include "iostream"
  2. using namespace std;
  4. int main()
  5. {
  6.     int line1[]={1,0,1};
  7.     int line2[]={1,0,1};
  8.     int line3[]={1,0,1};
  10.     //定义整型指针数组并初始化
  11.     int *pline[3]={line1,line2,line3};
  12.     cout <<"矩阵："<< endl;
  14.     //输出
  15.     for(int i=0;i<3;i++)
  16.     {
  17.         for(int j=0;j<3;j++)
  18.         {
  19.             cout <<pline[i][j]<<" ";
  20.         }
  21.         cout << endl;
  22.     }
  23.     return 0;
  24. }
  25. 输出：
  26. 矩阵：
  27. 1 0 1
  28. 1 0 1
  29. 1 0 1

指针做形参

读入三个浮点数，将整数部分和小数部分分别输出

  1. #include "iostream"
  2. using namespace std;
  4. void splitFloat(float x, int *intPart, float *fracPart) {
  5.     *intPart = static_cast<int>(x); //取x的整数部分
  6.     *fracPart = x - *intPart; //取x的小数部分
  7. }
  8. int main() {
  9.     cout << "Enter 3 float point numbers:" << endl;
  10.     for(int i = 0; i < 3; i++) {
  11.         float x, f;
  12.         int n;
  13.         cin >> x;
  14.         splitFloat(x, &n, &f);	//变量地址作为实参
  15.         cout << "Integer Part = " << n <<endl<< "Fraction Part = " << f << endl;
  16.     }
  17.     return 0;
  18. }

指向常量的指针做形参

  1. #include "iostream"
  2. using namespace std;
  4. const int N = 6;
  5. void print(const int *p, int n);
  6. int main() {
  7.     int array[N];
  8.     for (int i = 0; i < N; i++)
  9.         cin>>array[i];
  10.     print(array, N);
  11.     return 0;
  12. }
  13. void print(const int *p, int n) {
  14.     cout << "{ " << *p;
  15.     for (int i = 1; i < n; i++)
  16.         cout << ", " << *(p+i);
  17.     cout << " }" << endl;
  18. }
  19. 输出：
  20. 1
  21. 2
  22. 3
  23. 4
  24. 5
  25. 6
  26. { 1, 2, 3, 4, 5, 6 }

函数指针

编写一个计算函数compute，对两个整数进行各种计算。有一个形参为指向具体算法函数的指针，根据不同的实参函数，用不同的算法进行计算。编写三个函数：求两个整数的最大值、最小值、和。分别用这三个函数作为实参，测试compute函数

  1. #include <iostream>
  2. using namespace std;
  4. int compute(int a, int b, int(*func)(int, int))
  5. { return func(a, b);}
  6. int max(int a, int b) // 求最大值
  7. { return ((a > b) ? a: b);}
  8. int min(int a, int b) // 求最小值
  9. { return ((a < b) ? a: b);}
  10. int sum(int a, int b) // 求和
  11. { return a + b;}
  13. int main()
  14. {
  15.     int a, b, res;
  16.     cout << "请输入整数a："; cin >> a;
  17.     cout << "请输入整数b："; cin >> b;
  18.     res = compute(a, b, & max);
  19.     cout << "Max of " << a << " and " << b << " is " << res << endl;
  20.     res = compute(a, b, & min);
  21.     cout << "Min of " << a << " and " << b << " is " << res << endl;
  22.     res = compute(a, b, & sum);
  23.     cout << "Sum of " << a << " and " << b << " is " << res << endl;
  24. }
  25. 输出：
  26. 请输入整数a：12
  27. 请输入整数b：32
  28. Max of 12 and 32 is 32
  29. Min of 12 and 32 is 12
  30. Sum of 12 and 32 is 44

动态数组类

  1. #include <iostream>
  2. #include <cassert>
  3. using namespace std;
  4. class Point { //类的声明同例6-16 … };
  5.     class ArrayOfPoints { //动态数组类
  6.     public:
  7.         ArrayOfPoints(int size) : size(size) {
  8.             points = new Point[size];
  9.         }
  10.         ~ArrayOfPoints() {
  11.             cout << "Deleting..." << endl;
  12.             delete[] points;
  13.         }
  14.         Point& element(int index) {
  15.             assert(index >= 0 && index < size);
  16.             return points[index];
  17.         }
  18.     private:
  19.         Point *points; //指向动态数组首地址
  20.         int size; //数组大小
  21.     };
  23. int main() {
  24.     int count;
  25.     cout << "Please enter the count of points: ";
  26.     cin >> count;
  27.     ArrayOfPoints points(count); //创建数组对象
  28.     points.element(0).move(5, 0); //访问数组元素的成员
  29.     points.element(1).move(15, 20); //访问数组元素的成员
  30.     return 0;
  31. }
  32. 运行结果：
  33. Please enter the number of points:2
  34. Default Constructor called.
  35. Default Constructor called.
  36. Deleting...
  37. Destructor called.
  38. Destructor called.

vector数组

  1. #include <vector>
  2. #include <iostream>
  4. int main()
  5. {
  6.     std::vector<int> v = {1,2,3};
  7.     for(auto i = v.begin(); i != v.end(); ++i)
  8.         std::cout << *i << std::endl;
  9.     for(auto e : v)//带范围的for循环
  10.         std::cout << e << std::endl;
  11. }

移动构造

函数返回含有指针成员的对象

（1）先给出使用深层复制构造函数，返回时构造临时对象，动态分配将临时对象返回到主调函数，然后删除临时对象。

  1. #include<iostream>
  2. using namespace std;
  4. class IntNum {
  5. public:
  6.     IntNum(int x = 0) : xptr(new int(x)){ //构造函数
  7.         cout << "Calling constructor..." << endl;
  8.     }
  9.     //n是参数对象的引用；*n.xptr取值；xptr(new int(*n.xptr)是深拷贝
  10.     IntNum(const IntNum & n) : xptr(new int(*n.xptr)){//复制构造函数
  11.         cout << "Calling copy constructor..." << endl;
  12.     };
  13.     ~IntNum(){ //析构函数
  14.         delete xptr;
  15.         cout << "Destructing..." << endl;
  16.     }
  17.     int getInt() { return *xptr; }
  18. private:
  19.     int *xptr;
  20. };
  21. //返回值为IntNum类对象
  22. IntNum getNum() {
  23.     IntNum a;//新建一个局部对象，调用构造函数
  24.     return a; //返回一个对象，调用复制构造函数
  25. }
  26. int main() {
  27.     IntNum p=getNum();
  28.     cout<<p.getInt()<<endl;
  29.     return 0;
  30. }
  31. 输出：
  32. Calling constructor...
  33. Calling copy constructor...
  34. Destructing...
  35. 0
  36. Destructing...

（2）使用移动构造函数，将要返回的局部对象转移到主调函数，省去了构造和删除临时对象的过程。

  1. #include<iostream>
  2. using namespace std;
  4. class IntNum {
  5. public:
  6.     IntNum(int x = 0) : xptr(new int(x)){ //构造函数
  7.         cout << "Calling constructor..." << endl;
  8.     }
  9.     IntNum(const IntNum & n) : xptr(new int(*n.xptr)){//复制构造函数
  10.         cout << "Calling copy constructor..." << endl;
  11.         //注：•&&是右值引用；•函数返回的临时变量是右值
  12.     }
  13.     IntNum(IntNum && n): xptr( n.xptr){ //移动构造函数
  14.         n.xptr = nullptr;
  15.         cout << "Calling move constructor..." << endl;
  16.     }
  17.     ~IntNum(){ //析构函数
  18.         delete xptr;
  19.         cout << "Destructing..." << endl;
  20.     }
  21.     int getInt() { return *xptr; }
  22. private:
  23.     int *xptr;
  24. };
  25. //返回值为IntNum类对象
  26. IntNum getNum() {
  27.     IntNum a;
  28.     return a;
  29. }
  30. int main() {
  31.     cout << getNum().getInt() << endl; return 0;
  32. }
  33. 输出：
  34. Calling constructor...
  35. Calling move constructor...
  36. Destructing...
  37. 0
  38. Destructing...

上面两个程序输出是有问题的，待解决！

字符串

string

  1. #include <string>
  2. #include <iostream>
  3. using namespace std;
  5. //根据value的值输出true或false
  6. //title为提示文字
  7. inline void test(const char *title, bool value)
  8. {
  9.     cout << title << " returns "
  10.          << (value ? "true" : "false") << endl;
  11. }
  12. int main() {
  13.     string s1 = "DEF";
  14.     cout << "s1 is " << s1 << endl;
  15.     string s2;
  16.     cout << "Please enter s2: ";
  17.     cin >> s2;
  18.     cout << "length of s2: " << s2.length() << endl;
  19. //比较运算符的测试
  20.     test("s1 <= \"ABC\"", s1 <= "ABC");
  21.     test("\"DEF\" <= s1", "DEF" <= s1);
  22. //连接运算符的测试
  23.     s2 += s1;
  24.     cout << "s2 = s2 + s1: " << s2 << endl;
  25.     cout << "length of s2: " << s2.length() << endl;
  26.     return 0;
  27. }
  28. 输出：
  29. s1 is DEF
  30. Please enter s2: eqwe
  31. length of s2: 4
  32. s1 <= "ABC" returns false
  33. "DEF" <= s1 returns true
  34. s2 = s2 + s1: eqweDEF
  35. length of s2: 7

getline

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  4. int main() {
  5.     for (int i = 0; i < 2; i++){
  6.         string city, state;
  7.         getline(cin, city, ',');
  8.         getline(cin, state);
  9.         cout << "City:" << city << ",State:" << state << endl;
  10.     }
  11.     return 0;
  12. }
  13. 输出：
  14. San Francisco,the United States
  15. City:San Francisco,State:the United States
  16.         Beijing,China
  17. City:Beijing,State:China

习题

（1）以下关于地址和指针的叙述中正确的是

  • 可以取变量的地址赋值给同类型的指针变量（对）
  • 可以取常量的地址赋值给同类型的指针变量
  • 可以取一个指针变量的地址赋给本指针变量，这样就使得指针变量指向自身
  • 所有指针变量如果未赋初值，则自动赋空值NULL

解析：A选项正确。常量存储在编译文件中，不能取地址。B选项错误。一个指针变量的地址只能赋给指向这种类型的指针变量，与其本身类型不同，不能赋值，C选项错误。未赋初值的指针变量自动赋任意地址值，D选项错误。

（2）要定义一个引用变量p使之引用类MyClass的一个对象,正确的定义语句是

  • MyClass p=MyClass;
  • MyClass p=new MyClass;
  • MyClass ＆p=new MyClass;
  • MyClass a, ＆p=a;（对），别名

（3）在C++的动态存储分配，下列说法正确的是？

  • new和delete是C++语言中专门用于动态内存分配和释放的函数
  • 动态分配的内存空间也可以被初始化（对）
  • 当系统内存不够时，会自动回收不再使用的内存单元，因此程序中不必用delete释放内存空间
  • 当动态分配内存失败时，系统会立刻崩溃，因此一定要慎用new

    分析：选项A，错，new 与delete是用于动态平衡分配与释放空间的运算符，不是函数;选项C，错，要使用delete释放空间，系统会统一管理，而不用delete释放的空间，会造成内存泄漏，这种程序用的次数多，会造成内存耗尽;选项D，错，不成功，会返回0。

    （4）C++11中，＆表示左值引用；＆＆表示右值引用——下列关于左值和右值的说法正确的是
  • 表达式等号左边的是左值，等号右边的是右值
  • 左值是指表达式结束后依然存在的持久对象（对）
  • 右值是指表达式结束后依然存在的持久对象
  • 可以对右值取地址

    分析：左值和右值都是针对表达式而言的，左值是指表达式结束后依然存在的持久对象，右值指表达式结束时就不再存在的临时对象——显然右值不可以被取地址。

c++：-3的更多相关文章

  1. java web 开发三剑客 -------电子书

    Internet,人们通常称为因特网,是当今世界上覆盖面最大和应用最广泛的网络.根据英语构词法,Internet是Inter + net,Inter-作为前缀在英语中表示“在一起,交互”,由此可知In ...

  2. 所有selenium相关的库

    通过爬虫 获取 官方文档库 如果想获取 相应的库 修改对应配置即可 代码如下 from urllib.parse import urljoin import requests from lxml im ...

  3. In-Memory：内存数据库

    在逝去的2016后半年,由于项目需要支持数据的快速更新和多用户的高并发负载,我试水SQL Server 2016的In-Memory OLTP,创建内存数据库实现项目的负载需求,现在项目接近尾声,系统 ...

  4. 从直播编程到直播教育：LiveEdu.tv开启多元化的在线学习直播时代

    2015年9月,一个叫Livecoding.tv的网站在互联网上引起了编程界的注意.缘于Pingwest品玩的一位编辑在上网时无意中发现了这个网站,并写了一篇文章<一个比直播睡觉更奇怪的网站:直 ...

  5. 【.net 深呼吸】细说CodeDom（8）：分支与循环

    有人会问,为啥 CodeDom 不会生成 switch 语句,为啥没生成 while 语句之类.要注意,CodeDom只关心代码逻辑,而不是语法,语法是给写代码的人用的.如果用.net的“反编译”工具 ...

  6. 【原】Android热更新开源项目Tinker源码解析系列之三：so热更新

    本系列将从以下三个方面对Tinker进行源码解析: Android热更新开源项目Tinker源码解析系列之一:Dex热更新 Android热更新开源项目Tinker源码解析系列之二:资源文件热更新 A ...

  7. App开发：模拟服务器数据接口 - MockApi

    为了方便app开发过程中,不受服务器接口的限制,便于客户端功能的快速测试,可以在客户端实现一个模拟服务器数据接口的MockApi模块.本篇文章就尝试为使用gradle的android项目设计实现Moc ...

  8. TODO：macOS编译PHP7.1

    TODO:macOS编译PHP7.1 本文主要介绍在macOS上编译PHP7.1,有兴趣的朋友可以去尝试一下. 1.下载PHP7.1源码,建议到PHP官网下载纯净到源码包php-7.1.0.tar.g ...

  9. In-Memory：在内存中创建临时表和表变量

    在Disk-Base数据库中,由于临时表和表变量的数据存储在tempdb中,如果系统频繁地创建和更新临时表和表变量,大量的IO操作集中在tempdb中,tempdb很可能成为系统性能的瓶颈.在SQL ...

  10. In-Memory：内存优化表的事务处理

    内存优化表(Memory-Optimized Table,简称MOT)使用乐观策略(optimistic approach)实现事务的并发控制,在读取MOT时,使用多行版本化(Multi-Row ve ...

随机推荐

  1. memcached 如何处理容错的？

    不处理! 在 memcached 节点失效的情况下,集群没有必要做任何容错处理.如 果发生了节点失效,应对的措施完全取决于用户.节点失效时,下面列出几种方 案供您选择: 忽略它! 在失效节点被恢复或替 ...

  2. Go 语言 结构体

    Go 语言 结构体 引言Go 语言中数组可以存储同一类型的数据,但在结构体中我们可以为不同项定义不同的数据类型结构体是由一系列具有相同类型或不同类型的数据构成的数据集合结构体表示一项记录,比如保存图书 ...

  3. Excel之“提取指定符号（中括号）中的字符”

    提取A1中[]内的字符函数:=MID(A1,SEARCH("[",A1)+1,SEARCH("]",A1)-SEARCH("[",A1)-1 ...

  4. 业务网关之AK中心建设

    啥是AK AK(Access Key)是一种身份证明,它解决了"资源的使用者是谁"这个问题,比如在生活中,身份证可以证明你是你,而在云计算或程序中,AK能证明你是这个应用的拥有者. ...

  5. 『现学现忘』Docker基础 — 37、ONBUILD指令介绍

    目录 1.ONBUILD指令说明 2.演示ONBUILD指令的使用 3.补充:crul命令解释 1.ONBUILD指令说明 ONBUILD是一个特殊的指令,它后面跟的是其它指令,比如 RUN, COP ...

  6. BGD(批量梯度下降）--学习笔记

    函数凸凹性: 用到的范数知识: 详细解释:每一个元素的平方再开方.补充损失函数: Huber Loss知识点 loss函数可以通过loss参数进行设置.SGDRegressor支持以下的loss函数: ...

  7. node-webkit文档翻译#package.json

    title: node-webkit文档翻译#package.json date: 2013-12-07 21:38:25 tags: node-webkit 基本示例 { "main&qu ...

  8. Codepen 每日精选（2018-4-16）

    按下右侧的"点击预览"按钮可以在当前页面预览,点击链接可以打开原始页面. 内容切换的交互效果https://codepen.io/jcoulterde... 报价卡片的交互效果ht ...

  9. css使Img图片居中显示

    <div class="flex-center listing-img"> <img v-if="item.imgUrl" v-bind:sr ...

  10. 关键字static、extern、volatile、详解及举例

    一.预备知识 1. 什么是局部变量?什么是全局变量?          所谓局部变量,就是指在函数内部定义的变量的,只在该函数范围内有效. 全局变量是指,在函数外部定义的变量为外部变量,即全局变量.它 ...