1.指针的基本概念
1)变量的地址
变量是内存变量的简称,在C++中,每定义一个变量,系统就会给变量分配一块内存,内存是有地址的。
C++用运算符&获取变量在内存中的起始地址。
语法:&变量名
2)指针变量
指针变量简称指针,它是一种特殊的变量,专用于存放变量在内存中的起始地址。
语法:数据类型 *变量名;
数据类型必须是合法的C++数据类型(int、char、double或其它自定义的数据类型)。
星号*与乘法中使用的星号是相同的,但是,在这个场景中,星号用于表示这个变量是指针。
3)对指针赋值
不管是整型、浮点型、字符型,还是其它的数据类型的变量,它的地址都是一个十六进制数。我们用整型指针存放整数型变量的地址;用字符型指针存放字符型变量的地址;用浮点型指针存放浮点型变量的地址,用自定义数据类型指针存放自定义数据类型变量的地址。
语法:指针=&变量名;
注意
● 对指针的赋值操作也通俗的被称为“指向某变量”,被指向的变量的数据类型称为“基类型”。
●如果指针的数据类型与基类型不符,编译会出现警告。但是,可以强制转换它们的类型。
4)指针占用的内存
指针也是变量,是变量就要占用内存空间。
在64位的操作系统中,不管是什么类型的指针,占用的内存都是8字节。
在C++中,指针是复合数据类型,复合数据类型是指基于其它类型而定义的数据类型,在程序中,int是整型类型,int*是整型指针类型,int*可以用于声明变量,可以用于sizeof运算符,可以用于数据类型的强制转换,总的来说,把int*当成一种数据类型就是了。
2.使用指针
声明指针变量后,在没有赋值之前,里面是乱七八糟的值,这时候不能使用指针。
指针存放变量的地址,因此,指针名表示的是地址(就像变量名可以表示变量的值一样)
*运算符被称为间接值或解除引用(解引用)运算符,将它用于指针,可以得到该地址的内存中存储的值,*也是乘法符号,C++根据上下文来确定所指的是乘法还是解引用。
变量和指向变量的指针就像同一枚硬币的两面。
哪个银行? 什么东西? 数额
程序在存储数据的时候,必须跟踪三种基本属性:
●数据存储在哪里;
●数据是什么类型;
●数据的值是多少。
用两种策略可以达到以上目的:
声明一个普通变量,声明时指出数据类型和变量名(符号名),系统在内部跟踪该内存单元。
声明一个指针变量,存储的值是地址,而不是值本身,程序直接访问该内存单元。
3.指针用于函数的参数
如果把函数的形参声明为指针,调用的时候把实参的地址传进去,形参中存放的是实参的地址,在函数中通过解引用的方法直接操作内存中的数据,可以修改实数的值,这种方法被通俗的称为地址传递或传地址。
值传递:函数的形参是普通变量。
传地址的意义如下:
●可以在函数中修改实参的值。
● 减少内存拷贝,提升性能。
示例:
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
// 调用函数的时候,调用者把数值赋给了函数的参数。
// 实参:调用者程序中书写的在函数名括号中的参数。
// 形参:函数的参数列表。
void func(int *no, string *str) // 向超女表白的函数。
{
cout << "亲爱的" << *no << "号:" << *str << endl;
*no = 8;
*str = "我有一只小小鸟。";
}
// 写一个函数,从3名超女的身高数据中,选出最高的和最矮的。
void func1(int a, int b, int c, int* max, int* min)
{
*max = a > b ? a : b; // 取a和b中的大者。
*min = a < b ? a : b; // 取a和b中的小者。
*max = *max > c ? *max : c; // 取*max和c中的大者。
*min = *min < c ? *min : c; // 取*min和c中的大者。
}
int main()
{
int bh = 3; // 超女的编号。
string message = "我是一只傻傻鸟。"; // 向超女表白的内容。
func(&bh, &message); // 调用向超女表白的函数。
/*{
int *no = &bh;
string *str = &message;
cout << "亲爱的" << *no << "号:" << *str << endl;
*no = 8;
*str = "我有一只小小鸟。";
}*/
cout << "亲爱的" << bh << "号:" << message << endl;
// 从3名超女的身高数据中,选出最高的和最矮的。
int a = 180, b = 170, c = 175, m, n;
func1(a, b, c, &m, &n);
cout << "m=" << m << ",n=" << n << endl;
}
4.用const修饰指针
1)常量指针
语法:const 数据类型 *变量名;
不能通过解引用的方法修改内存地址中的值(用原始的变量名是可以修改的)。
注意:
●指向的变量(对象)可以改变(之前是指向变量a的,后来可以改为指向变量b)。
●一般用于修饰函数的形参,表示不希望在函数里修改内存地址中的值。
●如果用于形参,虽然指向的对象可以改变,但这么做没有任何意义。
●如果形参的值不需要改变,建议加上const修饰,程序可读性更好。
2)指针常量
语法:数据类型 * const 变量名;
指向的变量(对象)不可改变。
注意:
●在定义的同时必须初始化,否则没有意义。
●可以通过解引用的方法修改内存地址中的值。
●C++编译器把指针常量做了一些特别的处理,改头换面之后,有一个新的名字,叫引用。
3)常指针常量
语法:const 数据类型 * const 变量名;
指向的变量(对象)不可改变,不能通过解引用的方法修改内存地址中的值。
常引用。
常量指针:指针指向可以改,指针指向的值不可以更改。
指针常量:指针指向不可以改,指针指向的值可以更改。
常指针常量:指针指向不可以改,指针指向的值不可以更改。
记忆秘诀:*表示指针,指针在前先读指针;指针在前指针就不允许改变。
常量指针:const 数据类型 *变量名
指针常量:数据类型 * const 变量名
示例:
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
void func(const int *no, const string *str) // 向超女表白的函数。
{
// *no = 8;
// *str = "我有一只小小鸟。";
cout << "亲爱的" << *no << "号:" << *str << endl;
}
int main()
{
int a = 3, b = 8;
// 常量指针的语法:const 数据类型* 变量名;
// 不能通过解引用的方法修改内存地址中的值(用原始的变量名是可以修改的)。
/*
const int* p = &a;
a = 13;
cout << "a=" << a << ",*p=" << *p << endl;
p = &b;
cout << "b=" << b << ",*p=" << *p << endl;
*/
// 指针常量语法:数据类型* const 变量名;
// 指向的变量(对象)不可改变;在定义的同时必须初始化;可以通过解引用的方法修改内存地址中的值。
int* const p=&a;
*p = 13;
cout << "a=" << a << ",*p=" << *p << endl;
//int bh = 3; // 超女的编号。
//string message = "我是一只傻傻鸟。"; // 向超女表白的内容。
//
//func(&bh, &message); // 调用向超女表白的函数。
//cout << "亲爱的" << bh << "号:" << message << endl;
}
5.void关键字
在C++中,void表示为无类型,主要有三个用途:
1)函数的返回值用void,表示函数没有返回值。
void func(int a,int b)
{
// 函数体代码。
return;
}
2)函数的参数填void,表示函数不需要参数(或者让参数列表空着)。
int func(void)
{
// 函数体代码。
return 0;
}
3)的形参用void *,表示接受任意数据类型的指针。**
注意:
●不能用void声明变量,它不能代表一个真实的变量,但是,用void *可以。
●不能对void *指针直接解引用(需要转换成其它类型的指针)。
●把其它类型的指针赋值给void*指针不需要转换。
●把void *指针赋值给把其它类型的指针需要转换。
示例:
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
// 只关心地址本身,不关心里面的内容,用void *可以存放任意类型的地址。
// 显示变量的十六进制地址的函数:varname-变量名,p-变量的地址。
void func(string varname, void* p)
{
cout << varname<< "的地址是:" << p << endl;
cout << varname << "的值是:" << *(char *)p << endl;
}
int main()
{
int a=89;
char b='X';
cout << "a的地址是:" << & a << endl;
cout << "b的地址是:" << & b << endl;
func("a", &a);
func("b", & b);
}
6.二级指针
指针是指针变量的简称,也是变量,是变量就有地址。
指针用于存放普通变量的地址。
二级指针用于存放指针变量的地址。
声明二级指针的语法:数据类型** 指针名;
使用指针有两个目的:1)传递地址;2)存放动态分配的内存的地址。
在函数中,如果传递普通变量的地址,形参用指针;传递指针的地址,形参用二级指针。
把普通变量的地址传入函数后可以在函数中修改变量的值;把指针的地址传入函数后可以在函数中修改指针的值。
示例:
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
void func(int **pp)
{
*pp = new int(3);
cout << "pp=" << pp << ",*pp=" << *pp << endl;
}
int main()
{
/*int ii = 8; cout << "ii=" << ii << ",ii的地址是:" << &ii << endl;
int* pii = ⅈ cout << "pii=" << pii << ",pii的地址是:" << &pii << ",*pii=" << *pii << endl;
int** ppii = &pii; cout << "ppii=" << ppii << ",ppii的地址是:" << &ppii << ",*ppii=" << *ppii << endl;
cout << "**ppii=" << **ppii << endl;*/
int* p=0;
func(&p);
/*{
int** pp = &p;
*pp = new int(3);
cout << "pp=" << pp << ",*pp=" << *pp << endl;
}*/
cout << "p=" << p << ",*p=" << *p << endl;
}
7.空指针
在C和C++中,用0或NULL都可以表示空指针。
声明指针后,在赋值之前,让它指向空,表示没有指向任何地址。
1)使用空指针的后果
如果对空指针解引用,程序会崩溃。
如果对空指针使用delete运算符,系统将忽略该操作,不会出现异常。所以,内存被释放后,也应该把指针指向空。
在函数中,应该有判断形参是否为空指针的代码,目的是保证程序的健壮性。
为什么空指针访问会出现异常?
NULL指针分配的分区:其范围是从 0x00000000到0x0000FFFF。这段空间是空闲的,对于空闲的空间而言,没有相应的物理存储器与之相对应,所以对这段空间来说,任何读写操作都是会引起异常的。空指针是程序无论在何时都没有物理存储器与之对应的地址。为了保障“无论何时”这个条件,需要人为划分一个空指针的区域,固有上面NULL指针分区。
2)C++11的nullptr
用0和NULL表示空指针会产生歧义,C++11建议用nullptr表示空指针,也就是(void *)0。
NULL在C++中就是0,这是因为在C++中void* 类型是不允许隐式转换成其他类型的,所以之前C++中用0来代表空指针,但是在重载整形的情况下,会出现上述的问题。所以,C++11加入了nullptr,可以保证在任何情况下都代表空指针,而不会出现上述的情况,因此,建议用nullptr替代NULL吧,而NULL就当做0使用。
注意:在Linux平台下,如果使用nullptr,编译需要加-std=c++11参数。
示例:
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
void func(int* no, string* str) // 向超女表白的函数。
{
if ((no == 0) || (str == 0)) return;
cout << "亲爱的" << *no << "号:" << *str << endl;
}
int main()
{
// int bh = 3; // 超女的编号。
// string message = "我是一只傻傻鸟。"; // 向超女表白的内容。
int* bh = 0; // new int(3);
string* message = 0; // new string("我是一只傻傻鸟。");
func(bh,message); // 调用向超女表白的函数。
delete bh; delete message;
}
8.野指针
野指针就是指针指向的不是一个有效(合法)的地址。
在程序中,如果访问野指针,可能会造成程序的崩溃。
出现野指针的情况主要有三种:
1)指针在定义的时候,如果没有进行初始化,它的值是不确定的(乱指一气)。
2)如果用指针指向了动态分配的内存,内存被释放后,指针不会置空,但是,指向的地址已失效。
3)指针指向的变量已超越变量的作用域(变量的内存空间已被系统回收),让指针指向了函数的局部变量,或者把函数的局部变量的地址作为返回值赋给了指针。
规避方法:
1)指针在定义的时候,如果没地方指,就初始化为nullptr。
2)动态分配的内存被释放后,将其置为nullptr。
3)函数不要返回局部变量的地址。
注意:野指针的危害比空指针要大很多,在程序中,如果访问野指针,可能会造成程序的崩溃。是可能,不是一定,程序的表现是不稳定,增加了调试程序的难度。
9.函数指针
函数的二进制代码存放在内存四区中的代码段,函数的地址是它在内存中的起始地址。如果把函数的地址作为参数传递给函数,就可以在函数中灵活的调用其它函数。
使用函数指针的三个步骤:
a)声明函数指针;
b)让函数指针指向函数的地址;
c)通过函数指针调用函数。
1)声明函数指针
声明普通指针时,必须提供指针的类型。同样,声明函数指针时,也必须提供函数类型,函数的类型是指返回值和参数列表(函数名和形参名不是)
假设函数的原型是:
int func1(int bh,string str);
int func2(int no,string message);
int func3(int id,string info);
bool func4(int id,string info);
bool func5(int id);
则函数指针的声明是:
int (*pfa)(int,string);
bool (*pfb)(int,string);
bool (*pfc)(int);
pfa、pfb、pfc是函数指针名,必须用括号,否则就成了返回指针的函数。
2)函数指针的赋值
函数名就是函数的地址。
函数指针的赋值:函数指针名=函数名;
3)函数指针的调用
(*函数指针名)(实参);
函数指针名(实参);
示例:
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
void func(int no, string str)
{
cout << "亲爱的" << no << "号:" << str << endl;
}
int main()
{
int bh = 3; // 超女的编号。
string message = "我是一只傻傻鸟。"; // 向超女表白的内容。
func(bh, message);
void (*pfunc)(int, string); // 声明表白函数的函数指针。
pfunc = func; // 对函数指针赋值,语法是函数指针名=函数名。
pfunc(bh, message); // 用函数指针名调用函数。 C++
(*pfunc)(bh, message); // 用函数指针名调用函数。 C语言
}
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
void zs(int a) // 张三的个性化表白函数。
{
cout <<"a=" << a << "我要先翻三个跟斗再表白。\n"; // 个性化表白的代码。
}
void ls(int a) // 李四的个性化表白函数。
{
cout << "a=" << a << "我有一只小小鸟。\n"; // 个性化表白的代码。
}
void show(void (*pf)(int),int b)
{
cout << "表白之前的准备工作已完成。\n"; // 表白之前的准备工作。
pf(b); // 用函数指针名调用个性化表白函数。
cout << "表白之后的收尾工作已完成。\n"; // 表白之后的收尾工作。
}
int main()
{
show(zs, 3); // 张三要表白。
show(ls, 4); // 李四要表白。
}
参考资料:
慕课网
标签:变量,int,void,地址,80,指针,函数 From: https://www.cnblogs.com/codemagiciant/p/17365236.html