指针与数组

摘下来自己犯得很弱智的错误，哎，我竟然写出for(; p <= p+n-1; p++)这样的句子，p的值一直在变化嘛，还检查了很久，我真的是够了

#include <iostream>
#include <stdio.h>
using namespace std;
void average(float *p, int n);
void searc(float (*p)[4], int n);
int main()
{
    float score[3][4] = {{65,52,79,60},{80,87,90,81},{90,99,100,98}};
    average(*score, 12); //因为score是二维数组的名字，所以很容易看出来*score是列指针
    searc(score, 2);     //score是行指针
    return 0;
}
void average(float *p, int n)
{
    float *p_end = p+n-1, sum = 0, ave;
    for(; p <= p_end; p++)  //刚开始我竟然写成for(; p <= p+n-1; p++)， p的值一直在变化嘛，弱智错误！！！！！！！！！！！！
        sum = sum + (*p);
    ave = sum / n;
    printf("average = %5.2f
", ave);
}
void searc(float (*p)[4], int n)
{
    for(int i = 0; i < 4; i++)
    {
        printf("%5.2f ", *(*(p+n)+i));
    }
    printf("
");
}

关于动态内存分配： 

 感觉和c++中在堆中创建数据有点像哎，只是不知道存储机制一样不

#include <stdio.h>
#include <algorithm>
int main()
{
    int *p;
    p = (int *)malloc(sizeof(int));
    *p = 25;
    printf("%d
", *p);
    return 0;
}

二维数组中a+i, &a[i], a[i], *(a+i)的值相同，含义不同。
a+i与&a[i]表示第i行的首地址，指向行，a[i], *(a+i), &a[i][0]表示第i行第0列元素的地址，指向列。
&a[i]是列指针a[i]加取地址符号后得到的行指针
*(a+i)是有行指针a+i加上*变成的列指针。

(*(a+1))[1] = *(*(a+1)+1) = a[1][1]　　

/*定义指向一维数组的指针变量 
定义形式： 数据类型 (*指针变量名)[元素个数]，
比如int (*p)[4],括号不能省，int *p[4]与这里的p不同，这里p的值是一维数组的首地址，p是行指针;*/
#include <iostream>
using namespace std;
int main()
{
    int a[3][4] = { 1,2,3,4,3,4,5,6,5,6,7,8 };
    int i;
    int(*p)[4] = a, *q = a[0]; //p指向的对象是有四个整形元素一维数组，而q指向的对象是一个整形数据
    for (int i = 0; i < 3; i++)
    {
        if (i == 0)
        {
            (*p)[0] = *q + 1;
        }
        else
            p++, q++;
    }
    for (i = 0; i < 3; i++)
        cout << a[i][i] << " " << endl;
    cout << "**p: " << **p << " *q: " << *q << endl;
    return 0;
}

/*指针总结：
1：指针未被初始化一个地址或刚删除一个指针都要将其初始化为0，否则的话将会导致该指针失控
2：假如不想改变一个指针，那么将该指针定义为const，
假如不想改变该指针指向的值，将指针指向的值定义为const
假如即不想改变指针又不想改变指针指向的值，那么将指针和指针指向的值都定义为const

在new堆中创建一个对象，然后将内存地址赋给指针，之后我们就可以通过内存地址访问堆中的对象，
假如要删除该对象，我们只需要使用关键字delete，那么就会删除指针指向的对象并释放存储对象的内存空间，
但是我们要注意一点，指针并没有被删除，并且它仍指向原来的内存空间，因此我们必须对它的值清零或重新赋值*/

/*常量指针：自身不可以改变，但是它指向的目标却是可以改变的
用法：int a, int *const p = a;常量指针必须在定义时初始化*/

/*区分常量指针与指向常量的指针
指向常量的指针：
该指针指向的目标是不可以被修改的，但是该指针是可以被修改的
指向常量的指针只是限制我们修改它的目标，但是它本身是可以被修改的
const A *p2 = new A; //定义指向常量的指针*/

/*指向常量的常指针，它本身不可修改，它指向的目标也是不可修改的
定义方法：
const A*const p1 = new A;这就定义了一个指向常量的常指针*/
#include <iostream>
using namespace std;
class A
{
public:
    int get() const{return i;}
    void set(int x){i = x;}
private:
    int i;
};
int main()
{
    A *p = new A;
    p->set(10);
    cout <<"p:" << p << endl;
    p++;
    cout << "p:" << p << endl;
    A *const p1 = new A; //定义常量指针
    p1->set(11);
    cout <<"p1:" << p1 << endl;
    cout << p1->get() << endl;
    p1->set(11111);
    cout <<"p1:" << p1 << endl;
    cout << "p1:" << p1->get() << endl;
    const A *p2 = new A; //定义指向常量的指针
    p2++;
    const A *const p3 = new A;
    return 0;
}