Essential C++Notes -指针

指针带来的弹性

*指针实际上就是地址，&取地址操作，提领（取值）

一个未指向任何对象的指针，其地址值为0，称为null空指针。

type_of_object_pointed_to * name_of_pointer_object;
//指针的形式，需要指向的类型的 指针变量名

vector<int> *pv;	//一个指向“元素类型为int”的vector指针

//指针在调用之前可能未指向任何对象，需要先检验pv的值是否为0
pv && *pv

利用vector*来访问不同的vector

#include <iostream>
#include <string>
#include <vector>
using namespace std;
const int seq_size = 18;
int elem_seq[seq_size] = {
	1, 2, 3,	//Fibonacci
	3, 4, 7,	//Lucas
	2, 5, 12,	//Pell
	3, 6, 10,	//Triangular
	4, 9, 16,	//Square
	5, 12, 22	//Pentagonal
};

vector<int> fibonacci(elem_seq, elem_seq+3), Lucas(elem_seq+3, elem_seq+6),Pell(elem_seq+6, elem_seq+9),Triangular(elem_seq+9, elem_seq+12), Square(elem_seq+12, elem_seq+15), Pentagonal(elem_seq+15, elem_seq+18);//数列的初始化

const int max_seq = 6;
string seq_names[max_seq] = {
    "Fibonacci",
    "Lucas",
    "Pell",
    "Triangular",
    "Square",
    "Pentagonal"
};

vector<int>* seq_addrs[max_seq] = {		//指针数组
    &fibonacci, &Lucas, &Pell,
    &Triangular, &Square, &Pentagonal
};

int main()
{
	vector<int>* cur = 0;
	for (int i = 0; i < max_seq; i++)
	{
		cur = seq_addrs[i];	//cur指向是vector<int>的一个指针
		cout << seq_names[i] << endl;
		for (int j = 0; j < (*cur).size(); j++)	//*cur指向vector<int>
			cout << (*cur)[j] << " ";//也可以使用：cout << (*seq_addr[i])[j] << " "
		cout << endl;
	}
	return 0;
}

指针函数和函数指针

指针函数和函数指针（通过最后的名字来判断）

• 指针函数，返回的是一个指针，但它的主体是一个函数
• 函数指针，主体是一个指针，指向的是一个函数

const vector<int>* fibon_seq(int size);
//定义了一个指针函数（定义了一个函数fibno_seq，它的返回值类型是const vector<int>* 一个指向vector<int>的指针），返回一个fibon数组
const vector<int>* lucas_seq(int size);
const vector<int>* pell_seq(int size);
const vector<int>* triang_seq(int size);
const vector<int>* square_seq(int size);
const vector<int>* pent_seq(int size);

bool fibon_elem(int pos, int &elem){
    const vector<int> *pseq = fibon_seq(pos);//对于不同的数列而言，只是传入的函数不同
    if (!pseq){
        elem = 0;
        return false;
    }
    elem = (*pseq)[elem - 1];
    return true;
}

对不同的数列，难道也需要定义pell_elem吗?

在上面的代码中和数列相关的是fibon_seq，如果可以消除这个关联，那么就不必提供多个类似的fibon_elem。

对fibon_seq函数的实现

const vector<int>* fibon_seq(int size){ //fibon_seq的实现
    const vector<int>* res;             //res是一个指针常量(指向const vector<int>的指针)，因此不能修改指针所指的对象,不能直接向res中插入元素
    vector<int> temp;
    if (size < 1)   return res;
    
    for (int i = 0; i < size; i++){
        if (i < 2)  temp.push_back(1);
        else    temp.push_back(temp[i-1] + temp[i-2]);
    }

    return res = &temp;    
}

一种更简单的方式：

static vector<int> res;

返回结果时，在res前面添加取地址符&

函数指针（pointer to function），其形式相当复杂。他必须指明函数的返回值类型和参数列表。

函数指针的定义必须将*放在某个位置，表示这份定义所表现的是一个指针。

const vector<int>* *seq_ptr (int);
//错误的定义，将一个指针指向了另一个指针，后者指向了const vector

const vector<int>* (*seq_ptr) (int);
//const vector<int>* 函数的返回值类型，(*seq_ptr)指向seq_ptr函数的指针，int函数的形参

现在，seq_ptr可以指向“具有所列返回类型及参数列表”的任何一个函数。

重写fibon_elem使它变成更加通用的seq_elem

bool seq_elem(int pos, int &elem, const vector<int>* (*seq_ptr)(int)){
							   //调用seq_ptr所指的函数，传入函数指针
	 const vector<int>* pseq = seq_ptr(pos);
	 if (!pseq){
	 	elem = 0;
	 	return false;
	 }
	 elem = (*pseq)[pos-1];
	 return true;
}

由函数指针指向的函数，其调用方式和一般函数相同 ❤

#include <iostream>
using namespace std;

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

int substract(int a, int b)
{
    return a - b;
}

int main()
{
    int x = 5, y = 3;
    int (*pf)(int, int);	//函数指针的定义：返回值类型 (*函数名) (参数列表)
    pf = add;			   //pf指向一个函数
    cout << "pf point to add: " << pf(x, y) << endl;	//调用所值的函数

    pf = substract;
    pf(x, y);
    cout << "pf point to substract: " << pf(x, y) << endl;

    return 0;
}

const vector<int>* cur = seq_ptr(pos);

const vector<int>* fibon_seq(int size)
{
	static vector<int> elems;
	if (size <= 0 || size > 1024)
	{
		cout << "invalid size" << endl;
		return nullptr;
	}
	for (int i = elems.size(); i <= size; i++)
	{
		if (i < 2)	elems.push_back(1);
		else  elems.push_back(elems[i - 1] + elems[i - 2]);
	}
	return &elems;
}

const vector<int>* square_seq(int size)
{
	static vector<int> elems;
	if (size <= 0 || size > 1024)
	{
		cout << "invalid size" << endl;
		return nullptr;
	}
	for (int i = elems.size(); i <= size; i++)
	{
		elems.push_back((i+1) * (i+1));
	}
	return &elems;
}

bool seq_elem(int pos, int &elem, const vector<int> * (*seq_ptr)(int))
{
	const vector<int>* cur = seq_ptr(pos);
	if (!cur)
	{
		elem = 0;
		return false;
	}
	elem = (*cur)[pos - 1];
	return true;
}

int main()
{
	int pos = 12, elem;
	const vector<int>* (*seq_ptr) (int);
	seq_ptr = fibon_seq;
	cout << ( * seq_ptr(pos))[pos-1] << endl;
	cout << seq_elem(pos, elem, seq_ptr) << endl;
	return 0;
}