• C++ 第6章 数组、指针、字符串

    6.1 数组

    • 数组是具有一定顺序关系的若干相同类型变量的集合体，组成数组的变量称为该数组的元素。
    • 每个元素有n个下标的数组称为n维数组6.1.1 数组的声明与使用

    1、数组的声明

     

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

    • 例如: int a[5][3];
      表示a为整型二维数组，其中第一维有5个下标（0~4），第二维有3个下标（0~2），数组的元素个数为15，可以用于存放5行3列的整型数据表格。

    2、数组的使用

    必须先声明，后使用。
    只能逐个引用数组元素，而不能一次引用整个数组
    例如：a[0]=a[5]+a[7]-a[2*3]
    例如：b[1][2]=a[2][3]/2
    例：

    #include <iostream>
using namespace std;
int main() {
  int a[10], b[10];
  for(int i = 0; i < 10; i++) {
      a[i] = i * 2 - 1;
      b[10 - i - 1] = a[i];
  }

  for(int i = 0; i < 10; i++) {
      cout << "a[" << i << "] = " << a[i] << " ";
      cout << "b[" << I << "] = " << b[i] << endl;
  }
  return 0;
}

    6.1.2 数组的存储与初始化

    1、一位数组的存储

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

    2、一位数组的初始化

    在定义数组时给出数组元素的初始值。

    • 列出全部元素的初始值

    例如：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}

    3、二维数组的存储

    • 按行存放

    例如： float a[3][4];
    可以理解为：
     

    其中数组a的存储顺序为：
    a00 a01 a02 a03 a10 a11 a12 a13 a20 a21 a22 a23

    4、二维数组的初始化

    • 将所有初值写在一个{}内，按顺序初始化
      例如：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；
    • 如果只对部分元素初始化，剩下的未显式初始化的元素，将自动被初始化为零；
    例: 求Fibonacci数列的前20项 
    #include <iostream>
using namespace std;
int main() {
    int f[20] = {1,1}; //初始化第0、1个数
    for (int i = 2; i < 20; i++) //求第2～19个数
        f[i] = f[i - 2] + f[i - 1];
    for (int i=0;i<20;i++) { //输出，每行5个数
        if (i % 5 == 0) cout << endl;
        cout.width(12); //设置输出宽度为12
        cout << f[i];
    }
    return 0;

}
    运行结果：
     

    6.1.3 数组作为函数参数 

    •  数组元素作实参，与单个变量一样。
    •  数组名作参数，形、实参数都应是数组名（实质上是地址，关于地址详见6.2），类型要一样，传送的是数组首地址。对形参数组的改变会直接影响到实参数组。
    例6-2 使用数组名作为函数参数
    主函数中初始化一个二维数组，表示一个矩阵，矩阵，并将每个元素都输出，然后调用子函数，分别计算每一行的元素之和，将和直接存放在每行的第一个元素中，返回主函数之后输出各行元素的和。 
    #include <iostream>
using namespace std;
void rowSum(int a[][4], int nRow) {  //计算二维数组a每行的值的和，nRow是行数
     for (int i = 0; i < nRow; i++) {
         for(int j = 1; j < 4; j++)
              a[i][0] += a[i][j];
     }
}

int main() {   //主函数   
  int table[3][4] = {{1, 2, 3, 4}, {2, 3, 4, 5}, {3, 4, 5, 6}};  //定义并初始化数组
     for (int i = 0; i < 3; i++)  { //输出数组元素
         for (int j = 0; j < 4; j++)
              cout << table[i][j] << "   ";
         cout << endl;
     }
     rowSum(table, 3);     //调用子函数，计算各行和
     for (int i = 0; i < 3; i++)       //输出计算结果
         cout << "Sum of row " << i << " is " << table[i][0] << endl;  
     return 0;
}
     

    6.1.4 对象数组

    1、对象数组定义与访问

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

    2、对象数组初始化

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

    3、数组元素所属类的构造函数

    • 元素所属的类不声明构造函数，则采用默认构造函数。
    • 各元素对象的初值要求为相同的值时，可以声明具有默认形参值的构造函数。
    • 各元素对象的初值要求为不同的值时，需要声明带形参的构造函数。
    • 当数组中每一个对象被删除时，系统都要调用一次析构函数。
    例：对象数组应用举例 
    //Point.h
#ifndef _POINT_H
#define _POINT_H
class Point { //类的定义
  public: //外部接口
      Point();
      Point(int x, int y);
      ~Point();
      void move(int newX,int newY);
      int getX() const { return x; }
      int getY() const { return y; }
      static void showCount(); //静态函数成员
  private: //私有数据成员
      int x, y;
};
#endif //_POINT_H
    //Point.cpp
#include <iostream>
#include "Point.h"
using namespace std;
Point::Point() : x(0), y(0) {
    cout << "Default Constructor called." << endl;
}
Point::Point(int x, int y) : x(x), y(y) {
    cout << "Constructor called." << endl;
}
Point::~Point() {
    cout << "Destructor called." << endl;
}
void Point::move(int newX,int newY) {
    cout << "Moving the point to (" << newX << ", " << newY << ")" << endl;
    x = newX;
    y = newY;
}
    //6-3.cpp
#include "Point.h"
#include <iostream>
using namespace std;
int main() {
    cout << "Entering main..." << endl;
    Point a[2];
    for(int i = 0; i < 2; i++)
        a[i].move(i + 10, i + 20);
    cout << "Exiting main..." << endl;
    return 0;
}
    基于范围的for循环

    6.1.5 程序实例

    例题6-4 利用Point类进行点的线性拟合

      

    //POint.h
#pragma once
#ifndef _POINT_H
#define _POINT_H

class Point
{
public:
    Point(float x = 0, float y = 0) :x(x), y(y) {};
    float getX() const { return x; }
    float getY() const { return y; }
private:
    float x, y;
};

#endif // !_POINT_H
    // 程序实例6-4.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include "pch.h"
#include "Point.h"
#include <iostream>
#include <cmath>
using namespace std;

//直线线性拟合，point为各点，nPoint为点数
float lineFit(const Point points[], int nPoint) {
    float avgX = 0, avgY = 0;
    float lxx = 0, lyy = 0, lxy = 0;
    for (int i = 0; i < nPoint; i++) {
        avgX += points[i].getX() / nPoint;  //计算x，y平均值
        avgY += points[i].getY() / nPoint;
    }
    for (int i = 0; i < nPoint; i++)
    {
        lxx += (points[i].getX() - avgX)*(points[i].getX() - avgX);
        lyy += (points[i].getY() - avgY)*(points[i].getY() - avgY);
        lxy += (points[i].getX() - avgX)*(points[i].getY() - avgY);
    }
    cout << "This line can be fitted bu y=ax+b" << endl;
    cout << "a=" << lxy / lxx << " ";  //输出回归系数a
    cout << "b=" << avgY - lxy * avgX / lxx << endl;//输出回归系数b
    return static_cast<float>(lxy / sqrt(lxx*lyy));//返回相关系数r
}
int main()
{
    Point p[10] = { Point(6,10), Point(14,20), Point(26,30), Point(33,40), Point(46,50), Point(54,60), Point(67,70), Point(75,80), Point(100,100) };
    float r = lineFit(p, 10); //进行线性回归计算
    cout << "Line coefficient r="<<r<< endl;
    return 0;
}
     

    6.2 指针

    6.2.1 内存空间的访问方式

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

    6.2.2 指针变量的声明

    • 指针也是一种数据类型，具有指针类型的变量称为指针变量。
    • 指针变量是用于存放内存单元地址的。
    声明：  数据类型  *标识符
    例：static int i;     static int *i_pointer=&i;  //声明了一个i_pointer指向整型变量的指针
    引用：
    例1：  i=3; 例2：  *i_pointer=3;

    6.2.3 与地址相关的运算"*"和"&"

    *  称为指针运算符，也称解析，表示获取指针所指向变量的值，这是一个一元操作符
    & 称取地址运算符

    6.2.4 指针的赋值

    语法形式：存储类型  数据类型  *指针名＝初始地址；
    例：  int *pa=&a;
    注意事项：
    • 用变量地址作为初值时，该变量必须在指针初始化之前已说明过，且变量类型应与指针类型一致。
    • 可以用一个已赋初值的指针去初始化另一 个指针变量。
    • 不要用一个内部 auto 变量去初始化 static 指针。
    一个数组，可以用它的名称来直接表示它的起始地址。数组名称实际上就是一个不能被赋值的指针，即指针常量。

    指针变量的赋值运算：
         指针名=地址
    • “地址”中存放的数据类型与指针类型必须相符。
    • 向指针变量赋的值必须是地址常量或变量，不能是普通整数。但可以赋值为整数0，表示空指针。
    • 指针的类型是它所指向变量的类型，而不是指针本身数据值的类型，任何一个指针本身的数据值都是unsigned long int型。
    • 允许声明指向 void 类型的指针。该指针可以被赋予任何类型对象的地址。 例： void *general;
    例题：指针的定义、赋值与使用 
    #include<iostream>
using namespace std;
void main()
{    int *i_pointer;    //声明int型指针i_pointer
    int i;    //声明int型数i
    i_pointer=&i;    //取i的地址赋给i_pointer
    i=10;    //int型数赋初值
    cout<<"Output int i="<<i<<endl; //输出int型数的值
    cout<<"Output int pointer i="<<*i_pointer<<endl;
                          //输出int型指针所指地址的内容
}
    关于指针类型，还需要注意：
    1、可以声明指向常量的指针，此时不能通过指针来改变所指对象的值，但指针本身可以改变，可以指向另外的对象。 
    int a；
const int *pl=&a；  //pl是指向常量的指针
int b；
pl = &b； //正确，pl本身的值可以改变
*pl=1；   //编译时出错，不能通过pl改变所指向的对象

    　　

    2、可以声明指针类型的常量，这时指针本身的值不能被改变。 
    int *const p2=&a；
p2=&b； //错误，p2是指针常量，值不能改变

    　　

    1、一般情况下，指针的值只能赋给相同类型的指针。但是有一种特殊的void类型指针，可以存储任何类型的对象地址，就是说任何类型的指针都可以赋值给void类型的指针变量。经过使用类型显式转换，通过void类型的指针便可以访问任何类型的数据。 
    void vobject;  //错，不能声明void类型的变量
void *pv;	     //对，可以声明void类型的指针
int i=5;
void main()    //void类型的函数没有返回值
{
	pv = &i;	    //void类型指针指向整型变量
    int *pint = (int *)pv;    // void指针赋值给int指针需要类型强制转换:
}

    　　

    6.2.5 指针运算

    • 指针与整数的加减运算
      • 指针 p 加上或减去 n ，其意义是指针当前指向位置的前方或后方第 n 个数据的地址。
      • 这种运算的结果值取决于指针指向的数据类型。
    • 指针加一，减一运算
      • 指向下一个或前一个数据。
      • 例如：y=*px++ 相当于 y=*(px++) (*和++优先级相同，自右向左运算)
    • 关系运算
      • 指向相同类型数据的指针之间可以进行各种关系运算。
      • 指向不同数据类型的指针，以及指针与一般整数变量之间的关系运算是无意义的。
      • 指针可以和零之间进行等于或不等于的关系运算。例如：p==0或p!=0
    • 赋值运算
      • 向指针变量赋的值必须是地址常量或变量，不能是普通整数。但可以赋值为整数0，表示空指针。

    6.2.6 用指针处理数组元素

    声明与赋值
    例：
    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]都是等效的。
    • 不能写 a++，因为a是数组首地址是常量。
    例题：设有一个int型数组a，有10个元素。用三种方法输出各元素： 
    //使用数组名和下标
main()
{
   int a[10];
   int i;
   for(i=0; i<10; i++)
     cin>>a[i];
   cout<<endl;
   for(i=0; i<10; i++)
     cout<<a[i];
}
//使用数组名和指针运算
main()
{
   int a[10];
   int i;
   for(i=0; i<10; i++)
      cin>>a[i];
   cout<<endl;
   for(i=0; i<10; i++)
     cout<<*(a+i);
}
//使用指针变量
main()
{
   int a[10];
   int *p,i；
   for(i=0; i<10; i++)
        cin>>a[i];
   cout<<endl;
   for(p=a; p<(a+10); p++)
        cout<<*p;
}

    6.2.7 指针数组

    数组的元素是指针型.
    例：Point  *pa[2];
    例题：利用指针数组输出单位矩阵 
    #include <iostream>
using namespace std;
void main()
{    int line1[]={1,0,0};    //声明数组，矩阵的第一行
    int line2[]={0,1,0};    //声明数组，矩阵的第二行
    int line3[]={0,0,1};    //声明数组，矩阵的第三行
    int *p_line[3]={line1,line2,line3};    //声明整型指针数组并初始化指针数组元素
    
   cout<<"Matrix test:"<<endl;  //输出单位矩阵
    for(int i=0;i<3;i++)    //对指针数组元素循环
    {
        for(int j=0;j<3;j++)    //对矩阵每一行循环
        {   cout<<p_line[i][j]<<" ";   }
        cout<<endl;
    }
}
    输出结果为：
    Matrix test:
    1,0,0
    0,1,0
    0,0,1
    例题：二维数组举例 
    #include <iostream>
using namespace std;
void main()
{    int array2[2][3]={{11,12,13},{21,22,23}};
    for(int i=0;i<2;i++)
    {  cout<<*(array2+i)<<endl;    
        for(int j=0;j<3;j++)
        {  cout<<*(*(array2+i)+j)<<" ";   
           //或者 cout<<array2[i][j]<<" ";
        }    
        cout<<endl;
    }
}

    6.2.8 用指针作为函数参数

    • 以地址方式传递数据，可以用来返回函数处理结果。
    • 实参是数组名时形参可以是指针。
    例题：读入三个浮点数，将整数部分和小数部分分别输出 
    #include <iostream>
using namespace std;

//将实数X分成整数部分和小数部分，形参inPart、fracPart是指针
void  splitfloat(float x, int *intpart, float *fracpart)
{  //形参intpart、 fracpart是指针
    *intpart = int(x);    // 取x的整数部分
    *fracpart = x - *intpart; //取x的小数部分
}

void main(void)
{
    int i, n;
    float x, f;
        
    cout << "Enter three (3) floating point numbers"<< endl;
    for (i = 0; i < 3; i++)
    {
        cin >> x;
        splitfloat(x,&n,&f);       //变量地址做实参
        cout << "Integer Part is " << n << "   Fraction Part is " << f << endl;
    }
}
    例：输出数组元素的内容和地址 
    #include <iostream>
#include <iomanip>
using namespace std;
void Array_Ptr(long *P, int n)
{    int i;
    cout << "In func, address of array is " << unsigned long(P) << endl;
    cout << "Accessing array in the function using pointers"<< endl;
    for (i = 0; i < n; i++)
    {    cout << "   Address for index " << i << " is " << unsigned long(P+i);
        cout << "  Value is " << *(P+i)  << endl;
    }
}
void main(void)
{
    long list[5] = {50, 60, 70, 80, 90};
    cout << "In main, address of array is "
            << unsigned long(list) << endl;
    cout << endl;
    Array_Ptr(list,5);
}
    运行结果：
    In main, address of array is 6684132
    In func, address of array is 6684132
    Accessing array in the function using pointers
    Address for index 0 is 6684132  Value is 50
    Address for index 1 is 6684136  Value is 60
    Address for index 2 is 6684140  Value is 70    
    Address for index 3 is 6684144  Value is 80    
    Address for index 4 is 6684148  Value is 90
    例题：指向常量的指针做形参 
    #include<iostream>
using namespace std;
const int N=6;
void print(const int *p,int n);
void main()
{  int array[N];
    for(int i=0;i<N;i++)
         cin>>array[i];
    print(array,N);
}
void print(const int *p, int n)
{
     cout<<"{"<<*p;
     for(int i=1;i<n;i++)
         cout<<"."<<*(p+i);
     cout<<"}"<<endl;
}
     

    6.2.9 指针型函数

    当一个函数的返回值是指针类型（返回值是地址）时，这个函数就是指针型函类
    使用指针型函数的最主要目的就是要在函数结束时把大量的数据从被调函数返回到主调函数中。而通常非指针型函数调用结束后，只能返回一个变量或者对象。
    定义形式：
    数据类型  *函数名(函数表)
    {
      函数体
    }

    6.2.10 指向函数的指针

    函数指针就是专门用来存放函数代码首地址的变量。
    数据类型 （*函数指针名）(形参表)
    例： 
    #include <iostream>
using namespace std;
void print_stuff(float data_to_ignore);
void print_message(float list_this_data);
void print_float(float data_to_print);
void (*function_pointer)(float);    
void main()    
{
    float pi = (float)3.14159;
    float two_pi = (float)2.0 * pi;
   print_stuff(pi);
   function_pointer = print_stuff;
   function_pointer(pi);
   function_pointer = print_message;
   function_pointer(two_pi);
   function_pointer(13.0);
   function_pointer = print_float;
   function_pointer(pi);
   print_float(pi);
}
void print_stuff(float data_to_ignore)
{    cout<<"This is the print stuff function.
";    }

void print_message(float list_this_data)
{    cout<<"The data to be listed is " 
           <<list_this_data<<endl;    
}

void print_float(float data_to_print)
{    cout<<"The data to be printed is " 
           <<data_to_print<<endl;    
}
    运行结果：
    This is the print stuff function.  
    This is the print stuff function.  
    The data to be listed is 6.283180  
    The data to be listed is 13.000000  
    The data to be printed is 3.141590  
    The data to be printed is 3.141590

    6.2.11 对象指针：对象指针就是用于存放对象地址的变量。

    1、对象指针一般概念

    声明形式：
    类名  *对象指针名；
    例：
    Point A(5,10);
    Piont *ptr;   //声明Point类的对象指针变量ptr
    ptr=&A;    //将对象A的地址赋给ptr

    通过指针访问对象成员：
    对象指针名->成员名
    ptr->getx() 相当于 (*ptr).getx();
    例： 
    int main()
{
     Point A(5,10);
     Point *ptr;
     ptr=&A;
       int x;
       x=ptr->GetX();
       cout<<x<<endl;
     return 0;
}

    曾经出现过的错误例子：

    class Fred;    //前向引用声明
class Barney {
   Fred x;    //错误：类Fred的声明尚不完善
 };
class Fred {
   Barney y;
 };

    正确程序：

    class Fred;    //前向引用声明
class Barney {
   Fred *x;     
 };
class Fred {
   Barney y;
 };

    2、this指针

    • 隐含于每一个类的成员函数中的特殊指针（包括构造函数和析构函数）。
    • 明确地指向了成员函数当前所操作的数据所属的对象。
      • 当通过一个对象调用成员函数时，系统先将该对象的地址赋给this指针，然后调用成员函数，成员函数对对象的数据成员进行操作时，就隐含使用了this指针。
    例如：Point类的构造函数体中的语句： X=xx; Y=yy;
               相当于： this->X=xx; this->Y=yy;

    3、指向类的非静态成员的指针

    • 通过指向成员的指针只能访问公有成员
    • 声明指向成员的指针
      • 声明指向公有数据成员的指针
        • 类型说明符  类名::*指针名；    
      • 声明指向公有函数成员的指针
        • 类型说明符  (类名::*指针名)(参数表)；
    • 指向数据成员的指针
      • 说明指针应该指向哪个成员
        • 指针名=&类名::数据成员名；
      • 通过对象名（或对象指针）与成员指针结合来访问数据成员
        • 对象名.* 类成员指针名
        • 或：
        • 对象指针名—>*类成员指针名
    • 指向函数成员的指针
      • 初始化
        • 指针名=类名::函数成员名；
      • 通过对象名（或对象指针）与成员指针结合来访问函数成员
        • (对象名.* 类成员指针名)(参数表)
        • 或：
        • (对象指针名—>*类成员指针名)(参数表)
    例：访问对象的公有成员函数的不同方式 
    void main()    //主函数
{    Point A(4,5);    //声明对象A
    Point *p1=&A;    //声明对象指针并初始化
       int (Point::*p_GetX)()=Point::GetX;     //声明成员函数指针并初始化
    cout<<(A.*p_GetX)()<<endl;       //（1）使用成员函数指针访问成员函数
    cout<<(pl->*p_GetX)()<<endl;  //（2）使用成员函数指针和对象指针访问成员函数
    cout<<(p1->GetX)()<<endl;       //（3）使用对象指针访问成员函数
    cout<<A.GetX()<<endl;        //（4）使用对象名访问成员函数
}

    4、指向类的静态成员的指针

    • 对类的静态成员的访问不依赖于对象
    • 可以用普通的指针来指向和访问静态成员
    例：通过指针访问类的静态数据成员 
    #include <iostream>
using namespace std;
class Point    //Point类声明
{public:    //外部接口
    Point(int xx=0, int yy=0) {X=xx;Y=yy;countP++;}//构造函数
    Point(Point &p);    //拷贝构造函数
    int GetX() {return X;}
    int GetY() {return Y;}
    static int countP;    //静态数据成员引用性说明
private:    //私有数据成员
    int X,Y;
};
Point::Point(Point &p)
{    X=p.X;  Y=p.Y;  countP++;  }

int Point::countP=0;    //静态数据成员定义性说明

void main()    //主函数
{   
    int *count=&Point::countP;   //声明一个int型指针，指向类的静态成员
    Point A(4,5);    //声明对象A
    cout<<"Point A,"<<A.GetX()<<","<<A.GetY();
    //直接通过指针访问静态数据成员
    cout<<" Object id="<<*count<<endl;    
    Point B(A);    //声明对象B
    cout<<"Point B,"<<B.GetX()
           <<","<<B.GetY();
    //直接通过指针访问静态数据成员
    cout<<" Object id="<<*count<<endl;     
}
    例：通过指针访问类的静态函数成员 
    #include <iostream>
using namespace std;
class Point    //Point类声明
{ public:    //外部接口
    //其它函数略
    static void GetC()    //静态函数成员
           {cout<<" Object id="<<countP<<endl;}
   private:    //私有数据成员
    int X,Y;
    static int countP;    //静态数据成员引用性说明
};
// 函数实现略
int Point::countP=0;    //静态数据成员定义性说明
void main()    //主函数
{
   
    void (*gc)()=Point::GetC;       //指向函数的指针，指向类的静态成员函数
    Point A(4,5);    //声明对象A
    cout<<"Point A,"<<A.GetX()<<","<<A.GetY();
    gc();   //输出对象序号，通过指针访问静态函数成员
    Point B(A);    //声明对象B
    cout<<"Point B,"<<B.GetX()<<","<<B.GetY();
    gc();   //输出对象序号，通过指针访问静态函数成员
}
     

    6.3 动态内存分配  

    C++中动态内存分配技术可以保证程序在运行过程中按照实际需要申请适量的内存，使用结束后还可以释放，这种在程序运行过程中申请和释放的存储单元也称为堆对象，申请和释放过程一般称为建立和删除。

    1、动态申请内存操作符 new

    new  类型名T（初值列表）
    功能：在程序执行期间，申请用于存放T类型对象的内存空间，并依初值列表赋以初值。
    结果值： 成功：T类型的指针，指向新分配的内存。 失败：0（NULL）

    2、释放内存操作符 delete

    delete 指针P
    功能：释放指针P所指向的内存。P必须是new操作的返回值。
    注意：用new分配的内存，必须用delete加以释放，否则会导致动态分配的内存无法回收，使得程序占据的内存越来越大，这叫做“内存泄漏”。
    例： 
    #include<iostream>
using namespace std;
class Point
{ public:
    Point(){ 
       X=Y=0; 
       cout<<"Default Constructor called.
";
    }
    Point(int xx,int yy){
       X=xx;
       Y=yy ;
       cout<< "Constructor called.
";
    }
    ~Point(){
       cout<<"Destructor called.
";
    }
    int GetX() {return X;}
    int GetY() {return Y;}
    void Move(int x,int y) {  X=x;  Y=y;   }
  private:
       int  X,Y;
};
int main()
{   cout<<"Step One:"<<endl;
     Point *Ptr1=new Point; //动态创建对象，没有给出参数列表，因此调用默认构造函数
     delete  Ptr1;    //删除对象，自动调用析构函数
     cout<<"Step Two:"<<endl;  
     Ptr1=new Point(1,2); //动态创建对象，并给出参数列表，因此调用有形参的构造函数
     delete Ptr1;  //删除对象，自动调用析构函数
     return 0;
}
    运行结果：
    Step One:
    Default Constructor called.
    Destructor called.
    Step Two:
    Constructor called.
    Destructor called.

    3、例：动态创建对象数组举例

    #include<iostream>
using namespace std;
class Point
{ public:
    Point(){ 
       X=Y=0; 
       cout<<"Default Constructor called.
";
    }
    Point(int xx,int yy){
       X=xx;
       Y=yy ;
       cout<< "Constructor called.
";
    }
    ~Point(){
       cout<<"Destructor called.
";
    }
    int GetX() {return X;}
    int GetY() {return Y;}
    void Move(int x,int y) {  X=x;  Y=y;   }
  private:
       int  X,Y;
};
int main()
{   Point *Ptr=new Point[2];    //创建对象数组
     Ptr[0].Move(5,10);     //通过指针访问数组元素的成员
     Ptr[1].Move(15,20);   //通过指针访问数组元素的成员
     cout<<"Deleting..."<<endl;
     delete[ ] Ptr;               //删除整个对象数组
     return 0;
}
    运行结果：
    Default Constructor called.
    Default Constructor called.
    Deleting...
    Destructor called.
    Destructor called.
     

    4、例6-18：动态数组类

    #include<iostream>
using namespace std;
class Point
{   //类的声明同例6-16 …  };
class ArrayOfPoints
{   public:
     ArrayOfPoints(int n)
     {   numberOfPoints=n;  points=new Point[n];  }
     ~ArrayOfPoints()
     {   cout<<"Deleting..."<<endl;
         numberOfPoints=0;  delete[] points;     
      }
     Point& Element(int n)
     {  return points[n];  }
   private:
     Point *points;
     int numberOfPoints;
};
void main()
{
    int number;
    cout<<"Please enter the number of points:";
    cin>>number;
    //创建对象数组
    ArrayOfPoints points(number);    
    //通过指针访问数组元素的成员
    points.Element(0).Move(5,10); 
    //通过指针访问数组元素的成员
    points.Element(1).Move(15,20);   
}
    运行结果如下：
    Please enter the number of points:2
    Default Constructor called.
    Default Constructor called.
    Deleting...
    Destructor called.
    Destructor called.

    5、动态创建多维数组

    new  类型名T[下标表达式1][下标表达式2]…；
    如果内存申请成功，new运算返回一个指向新分配内存首地址的指针，是一个T类型的数组，数组元素的个数为除最左边一维外各维下标表达式的乘积。
    例如： char (*fp)[3]; fp = new char[2][3]; 
    #include<iostream>
using namespace std;
void main()
{    float (*cp)[9][8];
    int i,j,k;
    cp = new float[8][9][8];
    for (i=0; i<8; i++)
        for (j=0; j<9; j++)
            for (k=0; k<9; k++)
                *(*(*(cp+i)+j)+k)=i*100+j*10+k; 
                                        //通过指针访问数组元素
for (i=0; i<8; i++)
    {    for (j=0; j<9; j++)
        {      for (k=0; k<8; k++)
             //将指针cp作为数组名使用，
                       //通过数组名和下标访问数组元素
                      cout<<cp[i][j][k]<<"  ";  
            cout<<endl;
        }
        cout<<endl;
    }
}

    6、将动态数组封装成类

    更加简洁，便于管理
    可以在访问数组元素前检查下标是否越界
    例： 
    #include <iostream>
#include <cassert>
using namespace std;
class Point { //类的声明同例6-16 … };
class ArrayOfPoints { //动态数组类
    public:
       ArrayOfPoints(int size) : size(size) {
          points = new Point[size];
       }
       ~ArrayOfPoints() {
          cout << "Deleting..." << endl;
          delete[] points;
       }
       Point& element(int index) {
          assert(index >= 0 && index < size);
          return points[index];
       }
    private:
       Point *points; //指向动态数组首地址
       int size; //数组大小
};

int main() {
    int count;
    cout << "Please enter the count of points: ";
    cin >> count;
    ArrayOfPoints points(count); //创建数组对象
    points.element(0).move(5, 0); //访问数组元素的成员
    points.element(1).move(15, 20); //访问数组元素的成员
   return 0;
}
    为什么element函数返回对象的引用？
    返回“引用”可以用来操作封装数组对象内部的数组元素。如果返回“值”则只是返回了一个“副本”，通过“副本”是无法操作原来数组中的元素的

    7、智能指针

    显式管理内存在是能上有优势，但容易出错。
    C++11提供智能指针的数据类型，对垃圾回收技术提供了一些支持，实现一定程度的内存管理
    C++11的智能指针：
    • unique_ptr ：不允许多个指针共享资源，可以用标准库中的move函数转移指针
    • shared_ptr ：多个指针共享资源
    • weak_ptr ：可复制shared_ptr，但其构造或者释放对资源不产生影响

    8、动态存储分配函数

    void *malloc( size );
    参数size：欲分配的字节数
    返回值：   成功，则返回void型指针。              
                    失败，则返回空指针。
    头文件：   <cstdlib> 和 <cmalloc>

    9、动态内存释放函数

    void free( void *memblock );
    参数memblock：指针，指向需释放的内存。
    返回值：无
    头文件：<cstdlib> 和 <cmalloc>
     

    6.4 用vector创建数组对象

    为什么需要vector？
    • 封装任何类型的动态数组，自动创建和删除。
    • 数组下标越界检查。
    • 例6-18中封装的ArrayOfPoints也提供了类似功能，但只适用于一种类型的数组。
    vector对象的定义
    • vector<元素类型> 数组对象名(数组长度);
    • 例：
      • vector<int> arr(5)
      • 建立大小为5的int数组
    vector对象的使用
    • 对数组元素的引用
      • 与普通数组具有相同形式：
        • vector对象名 [ 下标表达式 ]
    • vector数组对象名不表示数组首地址
      • 获得数组长度
      • 用size函数
        • 数组对象名.size()
    例：vector应用举例 
    #include <iostream>
#include <vector>
using namespace std;

//计算数组arr中元素的平均值
double average(const vector<double> &arr)
{
    double sum = 0;
    for (unsigned i = 0; i<arr.size(); i++)sum += arr[i];
    return sum / arr.size();
}

int main() {
    unsigned n;
    cout << "n = ";
    cin >> n;
    vector<double> arr(n); //创建数组对象
    cout << "Please input " << n << " real numbers:" << endl;
    for (unsigned i = 0; i < n; i++)cin >> arr[i];
    cout << "Average = " << average(arr) << endl;
    return 0;

}
    例：基于范围的for循环配合auto举例 
    #include <vector>
#include <iostream>
int main()
{
    std::vector<int> v = {1,2,3};
    for(auto i = v.begin(); i != v.end(); ++i)
       std::cout << *i << std::endl;
    for(auto e : v)
       std::cout << e << std::endl;

}
     

    6.5  深复制和浅复制

    • 浅拷贝
      • 实现对象间数据元素的一一对应复制。
    • 深拷贝
      • 当被复制的对象数据成员是指针类型时，不是复制该指针成员本身，而是将指针所指的对象进行复制。
    例：对象的浅拷贝 
    #include<iostream>
using namespace std;
class Point
{   //类的声明同例6-16
    //……
};
class ArrayOfPoints
{
   //类的声明同例6-18
    //……
};
void main()
{    int number;
    cin>>number;
     ArrayOfPoints pointsArray1(number); pointsArray1.Element(0).Move(5,10); pointsArray1.Element(1).Move(15,20); 
    ArrayOfPoints pointsArray2(pointsArray1); 
    cout<<"Copy of pointsArray1:"<<endl;
    cout<<"Point_0 of array2: "
           <<pointsArray2.Element(0).GetX()
           <<", "<<pointsArray2.Element(0).GetY()<<endl;
    cout<<"Point_1 of array2: "
            <<pointsArray2.Element(1).GetX()
            <<", "<<pointsArray2.Element(1).GetY()<<endl;
   pointsArray1.Element(0).Move(25,30);    
   pointsArray1.Element(1).Move(35,40);   
   cout<<"After the moving of pointsArray1:"<<endl;
   cout<<"Point_0 of array2: "
         <<pointsArray2.Element(0).GetX()
         <<", "<<pointsArray2.Element(0).GetY()<<endl;
     cout<<"Point_1 of array2: "
         <<pointsArray2.Element(1).GetX()
         <<", "<<pointsArray2.Element(1).GetY()<<endl;
}
    运行结果如下：
    Please enter the number of points:2
    Default Constructor called.
    Default Constructor called.
    Copy of pointsArray1:
    Point_0 of array2: 5, 10
    Point_1 of array2: 15, 20
    fter the moving of pointsArray1:
    Point_0 of array2: 25, 30
    Point_1 of array2: 35, 40
    Deleting...
    Destructor called.
    Destructor called.
    Deleting... 接下来程序出现异常，也就是运行错误。

    例：对象的深拷贝 
    #include<iostream>
using namespace std;
class Point
{   //类的声明同例6-16 ……   };
class ArrayOfPoints
{   public:
     ArrayOfPoints(ArrayOfPoints& pointsArray);
    //其它成员同例6-18        
};
ArrayOfPoints ::ArrayOfPoints
(ArrayOfPoints& pointsArray)
{   numberOfPoints
         =pointsArray.numberOfPoints;
    points=new Point[numberOfPoints];
    for (int i=0; i<numberOfPoints; i++)
      points[i].Move(pointsArray.Element(i).GetX(),
                               pointsArray.Element(i).GetY());
}
void main()
{   //同例6-20   }
    程序的运行结果如下：
    Please enter the number of points:2
    Default Constructor called.
    Default Constructor called.
    Default Constructor called.
    Default Constructor called.
    Copy of pointsArray1:
    Point_0 of array2: 5, 10
    Point_1 of array2: 15, 20
    After the moving of pointsArray1:
    Point_0 of array2: 5, 10
    Point_1 of array2: 15, 20
    Deleting...
    Destructor called.
    Destructor called.
    Deleting...
    Destructor called.
    Destructor called.

    6.6 移动构造

          在现实中有很多这样的例子，我们将钱从一个账号转移到另一个账号，将手机SIM卡转移到另一台手机，将文件从一个位置剪切到另一个位置……移动构造可以减少不必要的复制，带来性能上的提升。
    • C++11标准中提供了一种新的构造方法——移动构造。
    • C++11之前，如果要将源对象的状态转移到目标对象只能通过复制。在某些情况下，我们没有必要复制对象——只需要移动它们。
    • C++11引入移动语义：
      • 源对象资源的控制权全部交给目标对象
    • 移动构造函数
    问题解决：当临时对象在被复制后，就不再被利用了。我们完全可以把临时对象的资源直接移动，这样就避免了多余的复制操作。

    移动构造

    • 什么时候该触发移动构造？
      有可被利用的临时对象

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

    例：函数返回含有指针成员的对象（版本1）

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

    #include<iostream>
using namespace std;

class IntNum {
   public:
      IntNum(int x = 0) : xptr(new int(x)){ //构造函数
         cout << "Calling constructor..." << endl;
      }
      IntNum(const IntNum & n) : xptr(new int(*n.xptr)){//复制构造函数
         cout << "Calling copy constructor..." << endl;
     };

     ~IntNum(){ //析构函数
        delete xptr;
        cout << "Destructing..." << endl;
     } 
    int getInt() { return *xptr; }
  private:
    int *xptr;
};

  //返回值为IntNum类对象
IntNum getNum() {
   IntNum a;
   return a;
}

int main() {
    cout<<getNum().getInt()<<endl;
    return 0;
}
    运行结果：
    Calling constructor...
    Calling copy constructor...
    Destructing...
    0
    Destructing...
    例：函数返回含有指针成员的对象（版本2）
    使用移动构造函数
    将要返回的局部对象转移到主调函数，省去了构造和删除临时对象的过程。 
    #include<iostream>
using namespace std;
class IntNum {
    public:
       IntNum(int x = 0) : xptr(new int(x)){ //构造函数
          cout << "Calling constructor..." << endl;
       }
       IntNum(const IntNum & n) : xptr(new int(*n.xptr)){//复制构造函数
          cout << "Calling copy constructor..." << endl;
       }
       IntNum(IntNum && n): xptr( n.xptr){ //移动构造函数
           n.xptr = nullptr;
           cout << "Calling move constructor..." << endl;
       }
       ~IntNum(){ //析构函数
          delete xptr;
          cout << "Destructing..." << endl;
       }
   private:
      int *xptr;
 };

//返回值为IntNum类对象
IntNum getNum() {
    IntNum a;
    return a;
 }

int main() {
    cout << getNum().getInt() << endl; return 0;
}
    运行结果：
    Calling constructor...
    Calling move constructor...
    Destructing...
    0
    Destructing...

    6.6 字符串

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

    6.6.1 用字符数组存储和处理字符串

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

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

    6.6.2 string 类

    • 使用字符串类string表示字符串
    • string实际上是对字符数组操作的封装

    1、string类常用的构造函数

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

    2、string类常用操作

    • 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'

    例： 
    #include <string>
#include <iostream>
using namespace std;
//根据value的值输出true或false
//title为提示文字
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 << "Please enter s2: ";
    cin >> s2;
    cout << "length of s2: " << s2.length() << endl;
    //比较运算符的测试
    test("s1 <= "ABC"", s1 <= "ABC");
    test(""DEF" <= s1", "DEF" <= s1);
    //连接运算符的测试
    s2 += s1;
    cout << "s2 = s2 + s1: " << s2 << endl;
    cout << "length of s2: " << s2.length() << endl;
    return 0;
}
    考虑：如何输入整行字符串？
    用cin的>>操作符输入字符串，会以空格作为分隔符，空格后的内容会在下一回输入时被读取

    3、输入整行字符串

    • getline可以输入整行字符串（要包string头文件）
      • 例如：getline(cin, s2);
    • 输入字符串时，可以使用其它分隔符作为字符串结束的标志（例如逗号、分号），将分隔符作为getline的第3个参数即可
      • 例如：getline(cin, s2, ',');
    例：用getline输入字符串 
    #include <iostream>
#include <string>
using namespace std;
int main() {
    for (int i = 0; i < 2; i++){
    string city, state;
    getline(cin, city, ',');
    getline(cin, state);
    cout << "City:" << city << “ State:" << state << endl;
    }
   return 0;

}
    运行结果：
    Beijing,China
    City: Beijing State: China
    San Francisco,the United States
    City: San Francisco State: the United States



     
  • 相关阅读:
    日报 18/07/10
    meta标签
    map 和 vector 的erase函数说明
    Intel CPU MMX SSE SSE2/3/4指令集手册下载URL
    关于c中 int, float, double转换中存在的精度损失问题
    c++ 常数后缀说明
    STL中容器的push()或者push_back()函数的一点说明
    fprintf, fscanf,printf,scanf使用时参数注意
    操作系统 庞丽萍 第七章
    辨析全局变量的声明与定义
  • 原文地址：https://www.cnblogs.com/alec7015/p/12445730.html
Copyright © 2020-2023  润新知