指针

内存空间的访问方式

如何利用内存单元存储数据？

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

具有静态生存期的变量——在程序运行之前，就已经分配了内存空间；

具有动态生存期的变量——在程序运行时，遇到变量声明语句时被分配内存空间的。

通过地址访问内存单元，why？

• • 在不同函数之间传送大量数据时，如果不传递变量的值，只传递变量的地址，就会减小系统开销，提高效率；
  • 如果是动态分配的内存单元，则根本就没有名称，这时只能通过地址访问。 

指针变量的声明

指针变量——用于存放内存单元地址

指针——可以指向指针

程序中声明一个变量时：

• • 声明了变量需要的内存空间；
  • 限定了对变量可以进行的运算及其运算规则；

地址运算符

* 

• • 声明语句中，在被声明的变量之前时，表示声明的是指针；
  • 执行语句中或声明语句的初始化表达式中，表示访问指针所指对象的内容。

 & 

• • 声明语句中，在被声明的变量左边时，表示声明的是引用；
  • 执行语句中或给变量赋初值在等号右边，表示取对象的地址。

指针的赋值

关于指针的类型，应注意： 

• 声明指向常量的指针

不能通过指针改变所指对象的值，但指针本身可改变

int a;

const int *p1=&a;

int const *p3=&a;

• 声明指针类型的常量

数组名——不能被赋值的指针(指针常量)

指针本身的值不可被改变 

int a;

int *const p2=&a;

• void类型指针——可以存储任何类型的对象地址

#include<iostream>
using namespace std;

int main()
{
    int i;

    int *ptr = &i;//i地址赋给ptr
    i = 10;

    cout << "i=" << i << endl;//直接访问
    cout << "ptr内容为：" << *ptr << endl;//间接访问

    cout << "ptr:" << ptr << endl;
    cout << "i的地址为：" << &i << endl << endl;


    int a;
    const int *p1 = &a;//指向常量的指针，指针内容不可变，指针本身可以变
    cout << "p1:" << p1 << endl;
    int b;
    p1 = &b;
    //*p1 = 1;
    cout << "p1:" << p1 << endl << endl;

    int *const p2 = &a;//指针类型的常量，指针本身的值不能改变
    //p2 = &b;
    cout << "p2:" << p2 << endl << endl;

    int const *p3 = &a;
    cout << "p3:" << p3 << endl;
    p3 = &b;
    cout << "p3:" << p3 << endl;

    return 0;
}

指针运算

指针p1和整数n1

p1+n1　　表示p1当前所指位置后方第n1个数的地址

p1++　　  表示指针当前所指位置下一个数据的地址

p1--

 

*(p1+n1)　　表示p1当前所指位置后方第n1个数的内容

p1[n1]　　　同上 

空指针用NULL或0表示，即一个不指向任何有效地址的指针（NULL是在很多头文件中都有定义的宏，被定义为0）；

用指针处理数组元素

数组名——数组存储的首地址

输出数组元素的三种方法：

#include<iostream>
using namespace std;
int main()
{
    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    cout << "数组元素:" << endl;
    for (int i = 0; i < 10; i++)
        cout << a[i] << endl;

    cout << "数组元素:" << endl;
    for (int i = 0; i < 10; i++)
        cout << *(a + i) << endl;

    cout << "数组元素:" << endl;
    for (int *pp = a; pp < (a + 10); pp++)
        cout << *pp << endl;
    return 0;
}

指针数组

由于指针数组的每个元素都是指针，必须先赋值后引用；

指针数组与二维数组的区别：

#include<iostream>
using namespace std;

int main()
{
    int array[3][3] = { { 11, 12, 13 }, { 21, 22, 23 }, { 31, 32, 33 } };

    cout << "数组元素" << endl;
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << array[i][j] << "    ";
        }
        cout << endl;
    }

    cout << "数组元素" << endl;
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << *(array[i] + j) << "    ";
        }
        cout << endl;
    }

    cout << "数组元素" << endl;
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << *(*(array + i) + j) << "    ";
        }
        cout << endl;
    }

    return 0;
}

指针作为函数参数

作用

1. 使实参与形参指向共同的内存空间，以达到参数双向传递的目的。即通过在被调函数中直接处理主函数中的数据，而将函数的处理结果返回其调用者；
2. 减少函数调用时数据传递的开销；
3. 通过指向函数的指针传递函数代码的首地址。

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

#include<iostream>
using namespace std;
void splitFLoat(float x, int *intPart, float *floatPart);

int main()
{
    float x;
    cout << "请输入x:";
    cin >> x;
    int intPart;
    float floatPart;
    splitFLoat(x, &intPart, &floatPart);
    cout << "intPart:    " << intPart << endl;
    cout << "floatPart:    " << floatPart << endl;
    return 0;
}


void splitFLoat(float x, int *intPart, float *floatPart)
{
    *intPart = static_cast<int>(x);
    *floatPart = x - *intPart;
}

 指针函数（函数返回值是指针类型——指针型函数）

目的：

在函数结束时，把大量数据从被调函数返回到主调函数中；

而通常非指针函数调用结束之后，只能返回一个变量或对象。

定义形式：

数据类型  *函数名(参数表)

{

　　函数体

}

函数名和“*”标识了一个指针型的函数

函数指针（指向函数的指针——用来存放代码首地址的变量）

在程序运行时，不仅数据要占据内存空间，执行程序的代码也被调入内存，并占据一定的内存空间。

每个函数的函数名表示函数的代码在内存中的起始地址，即：函数名（参数表）——函数代码首地址（参数表） 

通过赋值语句使指针分别指向三个函数，然后通过函数指针实现对函数的调用。

#include<iostream>
using namespace std;

void printStuff(float)
{
    cout << "stuff" << endl;
}

void printMessage(float  data)
{
    cout << "Message" << data << endl;
}

void printFloat(float data)
{
    cout << "float" << data << endl;
}

const float PI = 3.14;
const float TWO_PI = 2.0f*PI;

int main()
{
    void(*functionPointer)(float);

    printStuff(PI);
    functionPointer = printStuff;
    functionPointer(PI);

    functionPointer = printMessage;
    functionPointer(PI);
    functionPointer(13.21);

    functionPointer = printFloat;
    functionPointer(PI);
    printFloat(PI);

    return 0;
}

对象指针——存放对象地址的变量

对象所占据的内存空间只用来存放对象的数据成员，函数成员不在每一个对象中存储副本。

对象指针名->成员名

(*对象指针名).成员名（等价于上式） 

使用指针访问Point类的成员：

#include<iostream>
using namespace std;

class Point
{
public:
    Point(int x = 0, int y = 0) :x(x), y(y)
    {
    }

    int getX()
    {
        return x;
    }

    int getY()
    {
        return y;
    }

private:
    int x, y;
};

int main()
{
    Point a(4, 5);
    Point *p1 = &a;

    cout << p1->getX() << endl;
    cout << (*p1).getX() << endl;

    cout << a.getX() << endl;
    return 0;
}

对象指针在使用之前，一定要先进行初始化。

• this指针——隐含于每一个类的非静态成员函数中的特殊指针（包括构造函数和析构函数），它用于指向正在被成员函数操作的对象。

this是一个指针常量，对于常成员函数，this同时又是一个指向常量的指针。在成员函数中，可以使用*this来标识正在调用该函数的对象。

• 指向类的非静态成员的指针

指向对象成员的指针使用前也要先声明，再赋值，后引用。

声明指针语句的一般形式：

类型说明符  类名::*指针名;

类型说明符  (类名::*指针名)(参数表);

对数据成员指针赋值的一般语法形式：

指针名=&类名::数据成员名；

访问数据成员或成员函数时，可以通过将对象在内存中的起始地址与成员指针中存放的相对偏移结合实现：

对象名.*类成员指针名　　对象名.*类成员指针名(参数表)

对象指针名->*类成员指针名　　对象指针名->*类成员指针名(参数表)

成员函数指针在声明之后要对其赋值：

指针名=&类名::函数成员名

访问对象公有成员函数的不同方式：

#include<iostream>
using namespace std;

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

int main()
{
    Point a(3, 32);
    Point *p1 = &a;
    int (Point::*funPtr)() = &Point::getX;

    //访问对象的公有成员函数的不同方式
    cout << (a.*funPtr)() << endl;  //成员函数指针+对象名
    cout << (p1->*funPtr)() << endl;//成员函数指针+对象指针
    cout << a.getX() << endl;       //对象名
    cout << p1->getX() << endl;     //对象指针

    return 0;
}

• 指向类的静态成员指针

对类的静态成员的访问是不依赖于对象的，因此可以用普通的指针来指向和访问静态成员。

通过指针访问类的静态数据成员

#include<iostream>
using namespace std;

class Point{
public:

    Point(int x = 0, int y = 0) :x(x), y(y)
    {
        count++;
    }

    Point(const Point &p) :x(p.x), y(p.y)
    {
        count++;
    }

    ~Point()
    {
        count--;
    }

    int getX()
    {
        return x;
    }

    int getY()
    {
        return y;
    }

    static int count;

private:
    int x, y;
};

int Point::count = 0;

int main()
{
    int *ptr = &Point::count;
    Point a(3, 4);
    cout << "a:" << a.getX() << "," << a.getY() << endl;
    cout << "count=" << *ptr << endl;

    Point b(a);
    cout << "b:" << b.getX() << "," << b.getY() << endl;
    cout << "count=" << *ptr << endl;

    return 0;
}

通过指针访问类的静态函数成员 

#include<iostream>
using namespace std;
class Point{
public:

    Point(int x = 0, int y = 0) :x(x), y(y)
    {
        count++;
    }

    Point(const Point &p) :x(p.x), y(p.y)
    {
        count++;
    }

    ~Point()
    {
        count--;
    }

    int getX()
    {
        return x;
    }

    int getY()
    {
        return y;
    }

    static void showCount()
    {
        cout << "current count=" << count << endl;
    }

private:
    int x, y;
    static int count;

};

int Point::count = 0;

int main()
{
    void(*funPtr)() = Point::showCount;

    Point a(7, 8);
    cout << "a:" << a.getX() << "," << a.getY() << endl;
    funPtr();

    Point b(a);
    cout << "b:" << b.getX() << "," << b.getY() << endl;
    funPtr();
}