巩固C/C++

一：

& 运算符: 

当它后面跟一个变量名的时候,把这个变量名的地址取出来

#include <iostream>
using namespace std;
int main()
{
   int a=5;
   double b=10.4;
   cout<<"Address of a:"<<&a<<endl;
   cout<<"Address of b:"<<&b<<endl;
}

*运算符: 

就是后面跟一个指针或者说跟一个地址的时候,得到指针指向的内存中的内容

#include <iostream>
using namespace std;
int main()
{
   int a=5;
   double b=10.4;

   cout<<"Address of a:"<<&a<<endl;
   cout<<"Address of b:"<<&b<<endl;

   cout<<"a:"<<*(&a)<<endl;
}

声明指针的模板:

int * leo：

声明了一个指针，用来存放地址的；

int型表明这个指针是用来存放int型变量的地址的；

只能存int型变量的地址，其他类型的如float型的都不行

#include <iostream>
using namespace std;
int main()
{
  int a=5,b=6,c=7,d=8;
  double e=3.1415;
  //单独赋值,并且*和p_a紧挨着
  int *p_a=&a;
  //多个赋值(既有指针,又有普通变量)
  int * p_b=&b,* p_c=&c,*p_d=&d,temp=100;

  //单独赋值,double类型
  double * p_e=&e;

  cout<<p_a<<endl<<p_b<<endl<<p_c<<endl<<p_d<<endl<<p_e<<endl;
  cout<<temp<<endl;
}

void*：

Void*是一种特殊类型的指针,能够用来存放任何类型对象的地址.通俗来说,就是我不知道这个指针指向的是什么类型的对象. 

#include <iostream>
int fun(int num)
{
    return num+10;
}
int main()
{
    double x=25.5;
    //普通指针的话类型要严格保证
    double *p=&x;

    //void* 类型可以接受任意类型对象地址
    void *p_v=&x;
    void *p_v2=p;
    std::cout<<"p_v:"<<p_v<<std::endl;
    std::cout<<"p_v2:"<<p_v2<<std::endl;
}

指针的指针：

指针的指针就是指向指针的指针

#include <iostream>
int main()
{
   int a=10;
   int *p_a=&a;
   int **pp_a=&p_a;

   std::cout<<"p_a:"<<p_a<<std::endl<<"*p_a:"<<*p_a<<std::endl;
   std::cout<<std::endl;

   std::cout<<"PP_a:"<<pp_a<<std::endl<<"*pp_a:"<<*pp_a<<std::endl<<"**pp_a"<<**pp_a<<std::endl;

}

        void FindCredit(int **);

        main()
        {
            int vals[]={7,6,5,-4,3,2,1,0};
            int *fp=vals;
            FindCredit(&fp);
            printf(%d\n,*fp);
        }

        void FindCredit(int ** fpp)
        {
            while(**fpp!=0)
            if(**fpp<0) break;
            else (*fpp)++;
        }

char *Names[]=
        {
             Bill,
             Sam,
             Jim,
             Paul,
             Charles,
             0
        };

        main()
        {
            char **nm=Names;
            while(*nm!=0) printf(%s\n,*nm++);
        }

“指针函数”与“函数指针”

从字面意思来看，“指针函数”着重看后面两个字，它是一个函数，只不过它的返回值是一个指针，或者说是一个地址，如下：

int *f(x，y);

“函数指针”着重看后面两个字的话说明它是一个指针，这个指针所指向的类型不是int,也不是float，而是一个函数

int (*f) (int x); /* 声明一个函数指针 */

f = func; /* 将func函数的首地址赋给指针f */

void (*funcp)();
        void FileFunc(),EditFunc();

        main()
        {
            funcp=FileFunc;
            (*funcp)();
            funcp=EditFunc;
            (*funcp)();
        }

        void FileFunc()
        {
            printf(FileFunc\n);
        }

        void EditFunc()
        {
            printf(EditFunc\n);
        }

程序输出为：
        FileFunc

        EditFunc

常量指针和指针常量

常量指针是指向常量的指针，指针指向的内存地址的内容是不可修改的。

常量指针定义“const int *p=&a;”告诉编译器，*p是常量，不能将*p作为左值进行操作。但这里的指针p还是一个变量，它的内容存放常量的地址，所以先声明常量指针再初始化是允许的，指针也是允许修改的，例如：

int a=0,b=1;
const int *p;  //声明常量指针p
p=&a;            //p指向a
p=&b;            //修改指针p让其指向b，允许
*p=2;            //不允许

指针常量

指针常量是指针的常量，它是不可改变地址的指针，但可以对它所指向的内容进行修改。

指针常量定义"int *const p=&a;"告诉编译器，p是常量，不能作为左值进行操作，但允许修改其指向的内容，即*p是可修改的。指针常量必须在声明的同时对其初始化，不允许先声明一个指针常量随后再对其赋值，这和声明一般的常量是一样的，例如：

int a=0,b=1;
int *const p1=&a; 
int *const p2;       //不允许，必须对其初始化
p2=&b;                 //不允许，p2是常量不允许作为左值
*p1=2;                 //允许修改指针*p1的值

如果指针作为函数参数，当我们不想被调用函数随意修改参数指针而只是想修改参数指针指向的内容时，我们常把指针常量作为参数。例如：

有两个整形变量a，b，我们写个函数用于交换a，b的值，利用指针作为形参，函数修改参数指针的值是我们不希望的，这时可将参数设为指针常量，如果函数对指针修改编译是将报错。

void Exchange(int *const a,int *const b)
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp
}

可以看到，就看const放在谁的前面，如果放在int前面，则此int值不能改变，如果放在指针前，则此指针所指向的地址不能改变