c++指针的使用

已于 2023-03-03 12:07:43 修改
阅读量173 收藏
点赞数
分类专栏： C++11简单的使用方法 文章标签： c++ 开发语言
于 2023-03-02 21:54:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41701723/article/details/129308956
版权

c++指针的使用

指针基本概念

C++用运算符 & 获取变量在内存中的起始地址
在这里插入图片描述

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

int main()
{
    int a;
    char b;
    bool c;
    string d;
    //cout输出地址中，char类型的地址输出有 BUG
    cout<<"变量a的地址是"<<&a<<endl;
    cout<<"变量b的地址是"<<&b<<endl;
    cout<<"变量c的地址是"<<&c<<endl;
    cout<<"变量d的地址是"<<&d<<endl;
    cout<<"-------------------"<<endl;
    //解决方法1(16进制显示地址)
    cout<<"变量a的地址是"<<(void*)&a<<endl;
    cout<<"变量b的地址是"<<(void*)&b<<endl;
    cout<<"变量c的地址是"<<(void*)&c<<endl;
    cout<<"变量d的地址是"<<(void*)&d<<endl;
    cout<<"-------------------"<<endl;
    //解决方法2(10进制显示地址)
    cout<<"变量a的地址是"<<(long long)&a<<endl;
    cout<<"变量b的地址是"<<(long long)&b<<endl;
    cout<<"变量c的地址是"<<(long long)&c<<endl;
    cout<<"变量d的地址是"<<(long long)&d<<endl;
    cout<<"-------------------"<<endl;
    
}

指针变量

专用于存放变量在内存中的起始地址

指针变量 简称 指针

对指针(指针变量)赋值

  1. 对指针的赋值操作也通俗的被称为“指向某变量”，被指向的变量的数据类型称为“基类型”。
  2. 管是整型、浮点型、字符型，还是其它的数据类型的变量，它的地址都是一个十六进制数
#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

int main()
{
    int a=1;
    char b='b';
    bool c = true;
    string d = "ddd";

    int* a1;
    char* b1;
    bool* c1;
    string* d1;

    //指针赋值
    a1 = &a;
    b1 = &b;
    c1 = &c;
    d1 = &d;
	
	//获取指针变量所指向的变量的值
    cout<<"变量a的值为:"<<*a1<<endl;
    cout<<"变量b的值为:"<<*b1<<endl;
    cout<<"变量c的值为:"<<*c1<<endl;
    cout<<"变量d的值为:"<<*d1<<endl; 
}

指针占用的内存

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

int main()
{
    int* a1;
    char* b1;
    bool* c1;
    string* d1;

    cout<<sizeof(a1)<<endl;
    cout<<sizeof(b1)<<endl;
    cout<<sizeof(c1)<<endl;
    cout<<sizeof(d1)<<endl;

}

使用指针

*运算符被称为间接值或解除引用（解引用）运算符，将它用于指针，可以得到该地址的内存中存储的值

指针用于函数参数

地址传递:把函数的形参声明为指针，调用的时候把实参的地址传进去，形参中存放的是实参的地址,在函数中通过解引用的方法直接操作内存中的数据，可以修改实数的值

#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;
}

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;
    int* p2 = &a;
    *p2 = 100;
    cout<<a<<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;
}
  1. 指向的变量（对象）可以改变（之前是指向变量a的，后来可以改为指向变量b）。
  2. 一般用于修饰函数的形参，表示不希望在函数里修改内存地址中的值。
  3. 如果用于形参，虽然指向的对象可以改变，但这么做没有任何意义。
  4. 如果形参的值不需要改变，建议加上const修饰，程序可读性更好。

指针常量

指向的变量（对象）不可改变。

  1. 在定义的同时必须初始化，否则没有意义。
  2. 可以通过解引用的方法修改内存地址中的值。
#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;
    // int* p2 = &a;
    // *p2 = 100;
    // cout<<a<<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;
}

常指针常量

指向的变量（对象）不可改变，不能通过解引用的方法修改内存地址中的值。(结合前面俩个)

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

void func(int* const no, const string* const str)    // 向超女表白的函数。 
{

	cout << "亲爱的" << *no << "号：" << *str << endl;
    *no = 8;
	//*str = "我有一只小小鸟。";
}

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;
    // int* p2 = &a;
    // *p2 = 100;
    // cout<<a<<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;
}

void *

表示接受任意数据类型的指针

  1. 不能对void *指针直接解引用（需要转换成其它类型的指针）。
  2. 把其它类型的指针赋值给void*指针不需要转换。
  3. 把void *指针赋值给把其它类型的指针需要转换。
#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

// 只关心地址本身，不关心里面的内容，用void *可以存放任意类型的地址。

// 显示变量的十六进制地址的函数：varname-变量名，p-变量的地址。
void func(string varname, void* p)
{
	cout << varname<< "的地址是：" << (long long)p << endl;
	cout << varname << "的值是：" << *(char *)p << endl;
}

int main()
{
	int    a=89;
	char b='X';
	
	cout << "a的地址是：" <<  (long long)& a << endl;
	cout << "b的地址是：" <<  (long long)& b << endl;

	func("a", &a);
	func("b", & b);
}

取值的时候得加 (char )，
就是把原本的void类型的指针转换为字符类型的指针，再解引用就可以取值了

c++内存模型

内存主要分成四个区，分别是

  • 栈：存储局部变量、函数参数和返回值
  • 堆：存储动态开辟内存的变量。
  • 数据段：存储全局变量和静态变量。
  • 代码段：存储可执行程序的代码和常量（例如字符常量），此存储区不可修改。
    -在这里插入图片描述

栈和堆的主要区别

1）管理方式不同：栈是系统自动管理的，在出作用域时，将自动被释放；堆需手动释放，若程序中不释放，程序结束时由操作系统回收。
2）空间大小不同：堆内存的大小受限于物理内存空间；而栈就小得可怜，一般只有8M（可以修改系统参数)。
3）分配方式不同：堆是动态分配；栈有静态分配和动态分配（都是自动释放）。
4）分配效率不同：栈是系统提供的数据结构，计算机在底层提供了对栈的支持，进栈和出栈有专门的指令，效率比较高；堆是由C++函数库提供的。
5）是否产生碎片：对于栈来说，进栈和出栈都有着严格的顺序（先进后出），不会产生碎片；而堆频繁的分配和释放，会造成内存空间的不连续，容易产生碎片，太多的碎片会导致性能的下降。
6）增长方向不同：栈向下增长，以降序分配内存地址；堆向上增长，以升序分配内存地址。

动态分配内存new 和delete

使用堆区的内存有四个步骤：
1）声明一个指针；
2）用new运算符向系统申请一块内存，让指针指向这块内存；
3）通过对指针解引用的方法，像使用变量一样使用这块内存；
4）如果这块内存不用了，用delete运算符释放它。

  • 动态分配出来的内存没有变量名，只能通过指向它的指针来操作内存中的数据。
  • 如果动态分配的内存不用了，必须用delete释放它，否则有可能用尽系统的内存。
  • 动态分配的内存生命周期与程序相同，程序退出时，如果没有释放，系统将自动回收。
  • 就算指针的作用域已失效，所指向的内存也不会释放。
  • 用指针跟踪已分配的内存时，不能跟丢。
#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

int main()
{
	// 1）声明一个指针；
	// 2）用new运算符向系统申请一块内存，让指针指向这块内存；
	// 3）通过对指针解引用的方法，像使用变量一样使用这块内存；
	// 4）如果这块内存不用了，用delete运算符释放它。
	// 申请内存的语法：new 数据类型(初始值);   // C++11支持{}
	// 释放内存的语法：delete 地址;
	int* p = new int(5);
	cout << "*p=" << *p << endl;
	*p = 8;
	cout << "*p=" << *p << endl;
	delete p;

	//     for (int ii = 1; ii > 0; ii++)
	// {
	// 	int* p = new int[100000];     // 一次申请100000个整数，这个语法以后再讲。
	// 	cout << "ii="<<ii<<",p=" << p << endl;
	// }
}

二级指针

指针是指针变量的简称，也是变量，是变量就有地址。
指针用于存放普通变量的地址。
二级指针用于存放指针变量的地址。

使用指针有两个目的：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 = &ii;        cout << "pii=" << pii << ",pii的地址是：" << &pii << ",*pii=" << *pii << endl;
	int** ppii = &pii;  cout << "ppii=" << ppii << ",ppii的地址是：" << &ppii << ",*ppii=" << *ppii << endl;
	cout << "**ppii=" << **ppii << endl;

    cout<<"--------------"<<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;
}

空指针

在C和C++中，用0或NULL都可以表示空指针。
声明指针后，在赋值之前，让它指向空，表示没有指向任何地址。
如果对空指针解引用，程序会崩溃。(访问空指针)
如果对空指针使用delete运算符，系统将忽略该操作，不会出现异常。所以，内存被释放后，也应该把指针指向空。
在函数中，应该有判断形参是否为空指针的代码，目的是保证程序的健壮性。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。


int main()
{
    int* p= 0;
    cout<<"p="<<p<<"*p="<<*p<<endl;

    // delete p;
    // cout<<"成功删除空指针"<<endl;

    return 0;
}

NULL指针分配的分区：其范围是从 0x00000000到0x0000FFFF。这段空间是空闲的，对于空闲的空间而言，没有相应的物理存储器与之相对应，所以对这段空间来说，任何读写操作都是会引起异常的。空指针是程序无论在何时都没有物理存储器与之对应的地址。为了保障“无论何时”这个条件，需要人为划分一个空指针的区域，固有上面NULL指针分区

直接对空指针解引用，报错。。

#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;
}

加入判断形参是否为空指针的代码

#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;
}

或者，传递地址给形式参数

#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;
}

用0和NULL表示空指针会产生歧义，C++11建议用nullptr表示空指针，也就是(void *)0。(原因是和int类型重载)

#include<stdio.h>
void func(char* p)
{
	printf("第一个char*\n");
}
void func(int x)
{
	printf("第二个char*\n");
}
int main()
{
	func(NULL);
	return 0;
}

或者这个例子

#include<iostream>
using namespace std;
 
void func(char* p)
{
	cout << " char*" << endl;
}
void func(int x)
{
	cout << "int x" << endl;
}
int main()
{
	func(NULL);
	return 0;
}

在这里插入图片描述
同样的程序，在c语言中运行程序结果如我们所料是char * ,但在c++中程序运行打印的结果却是int x
参考博文
在C++11标准中，nullptr是一个所谓"指针空值类型"的常量。
在书写C++11代码时将NULL替换为nullptr可以使我们获得更加健壮的代码

#include<iostream>
using namespace std;
 
void func(char* p)
{
	cout << "char*" << endl;
}
void func(int x)
{
	cout << "int x" << endl;
}
int main()
{
	func(nullptr);
	func(0);
	func(NULL);
	return 0;
}

野指针

野指针就是指针指向的不是一个有效（合法）的地址。
在程序中，如果访问野指针，可能会造成程序的崩溃。

出现野指针的情况主要有三种：

  1. 指针在定义的时候，如果没有进行初始化，它的值是不确定的（乱指一气）。
  2. 如果用指针指向了动态分配的内存，内存被释放后，指针不会置空，但是，指向的地址已失效。
  3. 指针指向的变量已超越变量的作用域（变量的内存空间已被系统回收），让指针指向了函数的局部变量，或者把函数的局部变量的地址作为返回值赋给了指针。

如果访问野指针，可能会造成程序的崩溃。是可能，不是一定，程序的表现是不稳定，增加了调试程序的难度

#include<iostream>
using namespace std;
 

int main()
{
    int* p = (int*)0x0099999222;
    cout<<"p="<<p<<"*p="<<*p<<endl;
	return 0;
}

#include<iostream>
using namespace std;
 

int main()
{
    int* p = new int(3);
    cout<<"p="<<p<<"*p="<<*p<<endl;
    delete p;
    cout<<"p="<<p<<"*p="<<*p<<endl;
	return 0;
}

#include<iostream>
using namespace std;
 

int* func(){
    int a = 3;
    cout<<"a="<<a<<"&a="<<&a<<endl;
    return &a;
}

int main()
{
    int* p =func();
    cout<<"p="<<p<<"*p="<<*p<<endl;
	return 0;
}

规避方法：

  1. 指针在定义的时候，如果没地方指，就初始化为nullptr。
  2. 动态分配的内存被释放后，将其置为nullptr。
  3. 函数不要返回局部变量的地址。

函数指针

函数的二进制代码存放在内存四区中的代码段，函数的地址是它在内存中的起始地址。如果把函数的地址作为参数传递给函数，就可以在函数中灵活的调用其它函数

函数指针使用方法:

a）声明函数指针；
b）让函数指针指向函数的地址；
c）通过函数指针调用函数。

  1. 声明函数指针
    在这里插入图片描述
  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);          // 张三要表白。
    cout<<"------------------"<<endl;
	show(ls, 4);          // 李四要表白。
}
计算机CV民工
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++指针使用方法
01-19
　本文试图通过一些实际的指针使用经验来解释这个问题。 　仔细看一下这种声明方式，确实有点让人迷惑。在某种意义上，"*"和"&"是意思相对的两个东西，把它们放在一起有什么意义呢？。为了理解指针的这种做法，我们...
C++指针使用内容
06-09
对于C++指针的进阶使用规则和运用++
C++指针的使用
我的博客
10-18 5196
一、指针的定义和使用 可以通过指针来保存一个变量的地址 例如： int a=2; 就相当于内存中分出了一个内存块给变量a，而这个内存块中储存的数值为2； 假设这个内存块的地址为0x2e； 则可以通过定义一个指针来储存这个地址0x2e 指针就是一个地址 1、定义指针 指针定义的语法：数据类型*指针变量名； int * p; 让指针记录变量a的地址： p=&a;//&为取地址符号 cout<<"a的地址为："<<&a<<endl; cout<
指针在C++中的应用及顺序表结构体中的应用
华数云图小分队的博客
04-15 755
介绍了指针在C++中的应用，包括指针的概要、一级指针和二级指针的区别、指针的动态内存分配、指针参数的传递等。同时，通过一个生动的例子展示了使用二级指针来计算班级平均分的过程，并讲解了顺序表结构体中指针的应用。在实际开发中，指针是一个非常重要的工具，对于深入理解C++编程语言的原理以及更加高效地进行程序开发都具有重要意义。
C++017-C++指针及其应用
IT从业者的成长历程
04-15 656
本系列为C++学习系列，会介绍C++基础语法，基础算法与数据结构的相关内容。本文为C++指针及其应用案例，包括相关案例练习。
最详细的讲解C++中指针的使用方法（通俗易懂）
热门推荐
galaxyrt的博客
05-25 3万+
指针的定义与使用 函数的缺陷：一个函数只能返回一个值，就算我们在函数里面写多了return语句，但是只要执行任何一条return语句，整个函数调用就结束了。 数组可以帮助我们返回多个值，但是数组是相同数据类型的结合，对于不同数据类型则不能使用数组 使用指针可以有效解决这个问题，使用指针我们想反回几个值就能返回几个值，想返回什么类型就可以返回什么类型的值。 在程序设计过程中，存入数据还是取出数据都需要与内存单元打交道，计算机通过地址编码来表示内存单元。指针类型就是未了处理计算机地址数据的，计算机将内存
C++ 中的指针使用
qq_23921815的博客
03-06 383
C++指针的使用
c++指针使用形参改变实参的方法
08-31
C++指针使用形参改变实参的方法 C++语言中，指针是一种非常重要的数据类型，它可以用来间接访问内存中的数据。今天，我们将讨论如何使用指针作为形参来改变实参的值。 在C++中，函数的形参可以是指针类型的，这...
C++指针介绍及使用说明
10-09
总之，C++指针是一个强大的工具，但同时也伴随着风险。正确理解和使用指针，不仅可以提高程序的运行效率，还能解决许多复杂的问题。然而，如果不当使用，可能会引入难以调试的错误和安全隐患。因此，熟练掌握指针的...
C++智能指针原理及用法总结
ZZU_LGY
03-22 4377
weak_ptr是一个弱引用，它是为了配合shared_ptr 而引入的一种智能指针，它指向一个由shared_ptr管理的对象而不影响所指对象的生命周期，也就是 说，它只引用，不计数。由于a_ptr_是一个weak_ptr，它不会增加A对象的引用计数。实现原理：采用引用计数器的方法，允许多个智能指针指向同一个对象，每当多一个指针指向该对象 时，指向该对象的所有智能指针内部的引用计数加1，每当减少一个智能指针指向对象时，引用计数会 减1，当计数为0的时候会自动的释放动态分配的资源。
C++基础入门7 —— 指针
MWooooo的博客
11-02 498
1. 指针的基础概念 指针的作用：可以通过指针间接访问内存 内存编号从0开始，一般以十六进制表示 可以利用指针变量保存地址 2. 指针变量的定义和使用 int main() { int a = 10; int* p; //定义一个指针 p = &a; //将指针p指向a的地址 cout << "a的地址：" << &a << endl; cout << "p：" << p << endl;
【C++】详细讲解指针使用，带你玩转C++指针~
知识记录
07-30 6013
这一篇文章带你玩转C++的指针！
C++ 指针常见用法小结
GitChat
04-12 9496
本文主要面向 C++ 初学者。 指针在 C\C++ 语言中是很重要的内容，并且和指针有关的内容一向令初学者头大。在本教程中，我总结了一些关于指针和数组的用法（尤其是指针和二维数组）。初学者经常遇到的很多关于指针和数组的问题应该可以在本文找到答案。 本场 Chat 只有文章，没有交流。...
C++ 引用的指针和指针的引用
ck1n9的博客
02-24 1万+
C++不允许定义引用的指针，因为引用本身只是与另一个对象绑定在一起的该对象的别名，而并非一个对象，所以标准规定不能定义指向引用的指针报错： int a = 20; int &amp;*ptr = &amp;a;// error 参考&lt;&lt; C++ Premier 第五版&gt;&gt;，想要看懂声明符ptr的具体类型是什么，最简单的办法就是从右往左读，离变量名最近的符号对其类型有...
C++指针的应用
嵌入式Linux
12-01 536
C++指针文章中我们介绍了指针的基本概念和应用简介。我们有提到指针可以使用在链表、队列和二叉树，等等。但是这些都会比较复查，后面"数据结构” 时，我们会用专门的章节来讲解这些知...
C++: 指针的应用
belien
12-24 558
#include<iostream> using namespace std; //24 04 指针和函数.cpp void valuePass(int, int); void addressPass(int*, int*); void main() { int a = 10; int a2[] = { 1,2,3,4,5,6,7,8,9,0 }; //指针保存地址，地址指向数据 //1、定义一个指针：数据类型 * 指针变量名 int* p; //指针记录变量a的地址： .
C++ 指针的应用
酷小川的博客
02-23 212
一、指针与数组 首先看一段程序，来了解数组名与指针之间的用法。 #include "opencv.hpp" using namespace std; using namespace cv; int main() { int a[3] = { 1,3,4 }; int *aptr = a; for (int i = 0; i &lt; 3; i++) { cout &lt;&lt...
C++中指针的基本使用
z97i714的博客
02-19 428
大学的时候学过C和C++ 后来出去实习用的是Java 对指针的使用没有以前那么熟悉了 现在考研复试只能用C++进行上机考试 所以对C++又从新学习了一次 这次对指针的学习就做下笔记以免以后生疏又得重新学习一次 1.指针是一种地址变量 他只能够等于地址而不能够等于其他任何类型的数据值 2 指针与数组的关系： #include &lt;iostream&gt; using namespac...
c++指针使用前判空
最新发布
03-01
在C++中，使用指针之前判空是一种良好的编程习惯，可以避免空指针引发的错误。判空的目的是确保指针指向的内存地址是有效的，而不是空的或者无效的。 在使用指针之前，可以通过以下方式进行判空： 1. 直接判断指针是否为nullptr： ```cpp if (ptr == nullptr) { // 指针为空，进行相应处理 } else { // 指针不为空，可以安全地使用指针 } ``` 2. 使用条件语句判断指针是否为空： ```cpp if (ptr) { // 指针不为空，可以安全地使用指针 } else { // 指针为空，进行相应处理 } ``` 判空的目的是为了避免在使用指针之前出现空指针解引用的情况，从而导致程序崩溃或者产生未定义的行为。通过判空，可以提前处理指针为空的情况，保证程序的健壮性和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值