数组-指针-字符串

数组

数组的定义与初始化

• 类型符 数组名[常量表达式]；
• 数组必须先定义，再使用
• 数组名字是数组首元素的内存地址，是一个常量，不能被赋值
• 数组可以作为函数的参数：形参会影响实参，一般数组长度也要作为参数传入
• 对象数组

int a[10];  //定义整形一维数组
int a[2][5];  //定义整形二维数组
Point a[2];  //定义Point类对象数组

int a[10]={0,1,2,3};  //初始化
int a[]={0,1,2};    //编译器根据初始化的元素确定数组大小
Point a[2] = {Point(1,2), Point(3,4)};  //初始化

int a[2][2]={{1},{3,4}};  //二维初始化

//作为函数的参数 
#include <iostream>
using namespace std;

void add(int a[], int b[], int len_a, int len_b){
    for(int i=0;i<len_a;i++){
        a[i] = a[i] + b[i];
    }
}

int main(){
    int a[3] = {1,2,3};
    int b[3] = {4,5,6};
    add(a, b, 3, 3);
    for(int i=0; i<3;i++){
        cout << a[i] << endl;
    }
    return 0;
}

基于范围的for循环

int main(){
    int a[3] = {1,2,3};
    int *p;
    for(p = a; p < a + sizeof(a)/sizeof(int);p++){
        cout << *p << endl;
    }
    return 0;
}

int main(){
    int a[3] = {1,2,3};
    for(int & e:a){  //遍历容器，需要C++11标准
        cout << e << endl;
    }
    return 0;
}

vector

vector<int> arr(5);  //建立大小为5的int数组
arr.size();   //返回元素个数
arr[0];

add(vector<int> &v1, vector<int> &v2);

指针

指针的定义

• 本质为内存地址，间接访问存储单元
• 指针运算符 * 和 地址运算符 &
• *指向常量的指针 const int p = &a 不可以通过指针改变所指的对象
• 指针类型的常量 int * const p2 = &a p2的值不能更改，p2不能再指向别的对象
• 指针运算

int i=0, j=1;
int *p = &i;  //指针p指向i
int *p; p = &i; //指针p指向i
int *p = nullptr; //定义空指针，int *p = 0
int void *p;   //可以被赋予任何类型对象的地址；只能用于存放地址，不能通过它访问对象的值（可以先强制转换再访问）

*p = 3;  //通过指针间接更改i

int *p2 = &b;
p = p2;   //指针赋值

p = p + 1;  //指针向后方移动一个数据的大小，即指向下一个数据

指针与数组

int a[10];
int *p;
pa=&a[0]; pa = a;  //指针指向数组
//*p=a[0]    *(pa+1)=a[1]

指针数组

• 数组的元素为指针类型

int line1[] = {1,0,0};
int line2[] = {0,1,0};
int line3[] = {0,0,1};
int *p[3] = {line1, line2, line3}

指针与函数

• 指针作为函数的参数：双向传递， 数组太大
• 指针类型的函数 int* add(int, int)

指向函数的指针

存储类型 数据类型（*函数指针名）（形参列表）

典型用途：函数的回调（将函数指针作为函数的参数传递）

#include <iostream>
#include "point.h" 
using namespace std;

int compute(int a, int b, int(*func)(int, int))
{return func(a,b);}

int max(int a, int b)
{return ((a > b) ? a: b);}

int min(int a, int b)
{return ((a < b) ? a: b);}

int sum(int a, int b)
{return a+b;}

int main(){
    int a=1, b=2;
    cout << compute(a, b, &min) << endl;
    cout << compute(a, b, &max) << endl;
    cout << compute(a, b, &sum) << endl;
    return 0;
}

动态分配

动态内存分配

int *p = new int[10];
delete[] p;

int *p = new Point(1,2);
delete p;

字符串

C风格字符串

char str[8] = "hello";   //以\0为结尾
char str[] = "hello";

string

#include <string>
string s = "hello";
s[0] = 'H';

s1+s2; // 字符串拼接

s.length()

对象指针

this指针

通过一个对象调用成员函数时，系统会将该对象的地址赋值给this指针，然后调用成员函数时隐含的使用了this指针

//定义
Point a(5, 10);
Point *ptr = &a;
//访问对象成员
ptr->getX();  //等价于(*ptr).getX();
//this指针
int Point::getX()
{
    return x;  //等价于return this->x;
}

智能指针

unique_ptr ：不允许多个指针共享资源，可以使用move函数转移指针

shared_ptr：多个指针共享资源

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

对象的复制与移动

深拷贝与浅拷贝

浅拷贝：对象成员的一一复制，当对象中含有指针时，会导致多个指针指向同一个资源

深拷贝：指针不指向同一份资源，会新建另外一份资源，然后将资源的值一一复制过来

移动构造函数

不进行复制，而是转移（C++11）

可以对临时对象（即将消亡）的资源直接移动，避免了多余的复制操作

#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;
    }

    int getInt() { return *xptr; }

    private:
    int *xptr;
};

IntNum getNum() {
    IntNum a;
    return a;
}

int main() {
    cout << getNum().getInt() << endl;
    return 0;
}