c++学习之指针

56指针：

指针：可以通过指针来保存一个地址
简单来说，指针就是一个地址！！！

#include  <iostream>
using namespace std;

int main(){
//定义指针
int a=10;

//指针定义的语法： 数据类型 *指针变量名
int *p ;
p = &a;
cout<<"a的地址为："<<&a<<endl;
cout <<"指针p为：”<<p<<endl;

//使用指针:可以通过解引用的方式来找到指针指向的内存
//指针前加*表示解引用

*p = 1000;
cout<<"a="<<a<<endl;
cout<<"*p="<<*p<<endl;

system("pause");
return 0;
}

57.指针所占的内存空间
//在32位操作系统下，指针都是占用4个字节空间,不管是什么数据类型；64位下指针占8个字节。
//实验：指针所占的内存空间
int a=10;
int *p =&a;
cout<<"sizeof  (int *)="<<sizeof(p)<<endl;

cout<<"sizeof  (int *)="<<sizeof(int *)<<endl;

cout<<"sizeof  (int *)="<<sizeof(float *)<<endl;

cout<<"sizeof  (int *)="<<sizeof(double *)<<endl;

cout<<"sizeof  (int *)="<<sizeof(char *)<<endl;

58-59：空指针和野指针
空指针：指针变量只向内存中编号为0的空间。
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的。

实验：
int *p = NULL;

*p  = 100; //出现异常错误提示：写入访问权限冲突

//0-255之间的内存编号是系统占用的，因此不可以访问

野指针：指针变量指向非法的内存空间
int *p = (int *)0x1100;
cout <<*p<<endl;
//语法正确，但是发出异常，读取访问权限冲突

60.const修饰指针
const修饰指针有三种情况：
1.const修饰指针，称为常量指针
int b =10;
int  a =10;
int *p =&a;
const int *p =&a; //指针的指向可以修改，但指针指向的值不可以改

例子：
*p = 20; //错误
p = &b; //正确

2.const修饰指针，指针常量
int  * const p =&a;
特点：指针的指向不可以修改，指针指向的值可以修改

例子：
*p = 20 //正确
p = &b //错误               

3.const即修饰指针又修饰常量
const  int  * const  p =&a;
*p = 20; //错误
p = &b; //错误

61.指针和数组
作用：利用指针来访问数组中的元素
int arr[10] = {1,2,3,4,5,6,7,8,9,10};

count<<"第一个元素：”<<arr[0]<<endl;

int *p = arr;//数组名称arr就是数组的首地址
count<<"第一个元素：”<<*p<<endl;

p++；//让指针向后偏移4个字节

count<<"第二个元素：”<<*p<<endl;

实验：利用指针遍历数组

int *p2 = arr;
for (i=0;i<10;i++){
//count<<arr[i]<<endl;
count<<*p2<<endl;
p2++;
}

62.指针和函数
作用：利用指针作为函数参数，可以修改实参的值

//实现两个数字进行交换,值传递
void swap01(int a;int b){
int temp = a;
a = b;
b = temp;
}
int mian(){
int a = 10;
int b =20;
swap01(a,b);

cout<<"a="<<a<<endl;
cout<<"b="<<b<<endl;
}

实验：
//1.值传递

//2.地址传递

void swap02 (int * p1;int  *p2){
int temp = *p1;
*p1= *p2;
*p2 = temp;
}

int mian(){
int a = 10;
int b =20;
swap02(&a,&b);
cout<<"a="<<a<<endl;
cout<<"b="<<b<<endl;
}
如果是地址传递，可以修改实参。

63.指针、数组和函数
实验：封装一个函数，利用冒泡排序，实现对整型数组的升序排列
数组：int  arr[10] = {4,3,6,9,1,2,10,8,7,5};
步骤：
1.创建数组；
int  arr[10] = {4,3,6,9,1,2,10,8,7,5};
int len = sizeof(arr)/sizeof (arr[0]); //数组长度
2.创建函数，实现冒泡排序；
//参数1   数组的首地址       参数2       数组长度
void bubbleSort(int *arr,int len)
{
for （int i=0；i<len -1; i++）{

    for(int j=0;j<len-1;j++)
{
    if （arr[j]>arr[j+1]）
    {
          int temp = arr[j];
          arr[j] =arr[j+1];
          arr[j+1] = temp;
}
}
}

}
3.打印排序后的数组
void printArray(int *arr,int len)
{
     for （int i=0；i<len;i++）
      {
           cout<<arr[i]<<endl;

        }
}

6.sizeof关键字
作用：可以统计数据类型所占内存大小
语法：sizeof(数据类型或者变量）

实验：
short num1 = 10;
cout<<sizeof(short)<<endl; 输出：2
cout<<sizeof(num1)<<endl;

46.冒泡排序
算法：最常用的排序算法，对数组内元素进行排序

1.比较相邻的元素，如果第一个比第二个大，就交换他们。
2.对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
3.重复以上步骤，每一步比较次数-1，直到不要比较

实验：将4，2,8,0,5,7,1,3,9进行排序
对比次数：第一次8次
4与2比，比完交换
4和8
8和0
8和5
8和7
8和1
8和3
8和9

第一轮找到了最大数9
开始第二轮冒泡排序，找第二个最大数
开始第三轮冒泡排序，找第三个最大数

//利用冒泡排序实现升序序列
int arr[9]={4,2,8,0,5,7,1,3,9}
for (int i=0;i<9;i++)
{
     cout<<ar[i]<<"";
}
cout<<endl;

//开始冒泡排序
排序总轮数 = 元素个数 -1；
每轮对比次数 = 元素个数 - 排序论数-1；

for（int i =0；i<9;i++）
{
     //内层循环
    for（int j =0;j<9-i-1;j++）
  {
       //比大小，看是否交换
        if(arr[j]>arr[j+1])
  {
    int temp =arr[j];
    arr[j] = arr[j+1];
    arr[j+1] =temp;
   }

   }
}