精华内容
下载资源
问答
  • c++指针和地址
    千次阅读
    2021-06-15 19:05:58

    总结:

    char a = '1';
    char *b = 0;
    b = &a;
    

    b中存放的是所指向数据的地址,而&b中存放的是存放指针的地址;b中存放的指向数据的内容必须得先初始化后才可以使用*b获取数据内容或者对其进行赋值,不然会出现内存溢出问题;


    C++的指针和引用因为涉及到地址和地址当中的存储内容,所以比较容易混淆。首先需要注意的是,指针和引用存放的都是被引用对象的地址!地址!地址!比如对于指针,当我们定义一个指针p,比如说int* p = &a时,指针p必须指向一个地址(即等号右边必须是一个地址)。而*p则表示该地址中包含的内容(即a)。&这里是取地址符号,不是引用,但作用也是和地址相关,及取出变量的地址。

    好,现在我们接触到了第一个地址,就是变量的地址,这个地址中存放了变量的内容,在下面的例子中可以认为这个地址中存放着5这个数字。但是需要注意,还有一个地址不能被混淆,就是指向变量的指针自己的地址,因为指针也是需要存储空间的。这里指针变成了这个存储空间的内容,其地址和指针指向的地址无关,可以用取地址符号取出验证。

    下面来看一下简单的例子。

    #include <iostream>
    using namespace std;
     
    int main()
    {
      int a = 5;
      //指针p必须指向一个地址,不能用int*p = a
      //因为a只是一个变量,不能表示内存地址
      int* p = &a;
     
      cout << "a = " << a << endl;
      //*p表示指针指向的地址中的内容
      cout << "*p = " << *p << endl;
     
      cout << "&a = " << &a << endl;
      //p表示指针指向内容的地址
      cout << "p = " << p << endl;
     
      //这里&p是取指针的地址,和a及其地址没有任何关系
      cout << "&p = " << &p << endl;
      return 0;
    }
    

    运行的结果如下,即*p == a, p == &a, 而&p是指针p自己的存放地址,与a无关。

    以上是最基本的指针操作,但是除了基本的数据类型,指针还可以指向其他的复杂数据类型。以数组为例,数组的特殊之处在于,数组名即可以表示数组的名称,和之前的a一样,可以表示该数组的首地址和之前的&a一样,那么,int*p = a;这样的语句就可以成立。

    int b[] = {1, 2, 3};
      int* q = b;
     
      cout << "&b = " << &b << endl;
      cout << "b = " << b << endl;
      //这里可以发现,&b == b
     
      //这里q和b的功能上就完全一致了
      cout <<"q = " << q << endl;
      cout << "b[1] = " << b[1] << endl;
      cout << "q[1] = " << q[1] << endl;
     
      //同样的,q自己的地址和b没有任何关系
      cout <<"&q = " << &q <<endl;
    

    对于其他的复杂的或者自己定义的数据类型,在使用指针指向该类型的数据时,需要注意该类型的名称是否可以表示其首地址。还是最一开始的那句话,指针一定要指向地址,不能直接指向变量,除非该变量可以同时表示某个地址。比如自定义的结构体,结构体名称就不能表示该结构体的地址,所以使用方法要参考一般数据类型的,而不是数组的。另外,当指针指向结构体时,访问其内容的变量时不能用".“而要使用”->", 或者使用"*“号配合”."一起使用。

    struct student
    {
      string name;
      int score;
    };
     
     
    int main()
    {
      student st1;
      student st2;
      st1.name = "xiaoli";
      st1.score = 70;
     
      // 这里涉及到结构体指针,同样等号右边需要是一个地址
      // 这里注意的是,结构体名称不像数组名称一样可以表示地址
      student* m = &st1;
      cout << "st1.name = " << st1.name <<endl;
      cout << "m->name = " << m->name << endl;
      cout << "(*m).name = " << (*m).name << endl;
      
      return 0;
    }
    

    参考文章

    [1]C++ 指针与取地址&

    更多相关内容
  • C++指针地址和指针的值

    千次阅读 2018-12-28 19:57:49
    C++指针 学过C++ 都知道,指针是一个很重要的概念,他是C++的灵魂,在上学的时候从书山了解到,指针就是指向内存的地址,然,今天同事讨论指针传递引用传递的时候,我说:指针传递其实就是引用传递。打脸了。...

    C++指针

    学过C++ 都知道,指针是一个很重要的概念,他是C++的灵魂,在上学的时候从书山了解到,指针就是指向内存的地址,然,今天和同事讨论指针传递和引用传递的时候,我说:指针传递其实就是引用传递。打脸了。虽然他们都是对地址的操作,但是本质还是有区别的。
    在这里插入图片描述

    在这里插入图片描述
    也就是说引用传递就是变量的地址,指针传递的时候,是指针的值。但是指针的值和指针的地址是不同的。。。突然感觉自己好菜哦!!!

    展开全文
  • C和C++打印指针和地址

    千次阅读 2020-07-24 20:15:11
    1.C++ 中指针变量的地址和指针变量的值是两个不同的概念 指针变量的地址:这是指针变量这个变量在内存中的存储地址(如图所示0x1211) 指针的值:里面存放的是一个地址,此地址即为指向的内存单元的地址(如图所示0x...

    1.C++ 中指针变量的地址和指针变量的值是两个不同的概念

    指针变量的地址:这是指针变量这个变量在内存中的存储地址(如图所示0x1211)
    指针的值:里面存放的是一个地址,此地址即为指向的内存单元的地址(如图所示0x1101)
    

    在这里插入图片描述

    2.假如要输出指针变量的地址和指针变量的值

    char *str="Hello world";
    cout << hex << &str << endl;        //输出的是str指针变量的地址
    cout << hex << (void *)str << endl; //输出的是str指针的值
    cout << str <<endl;                 //输出的是字符串str
    

    3.注意

    指针之间的拷贝是浅拷贝,只拷贝了指针的值,不拷贝指针所指向的内存单元的内容
    
    展开全文
  • c++ 指针详解

    千次阅读 多人点赞 2022-03-28 14:37:51
    使用指针遍历数组 ;指针的概念与理解;...指针的解引用地址指针的算数操作 ;指针相减 ;const指针;指向const的指针指针的数组和数组的指针;数组的指针地址指针指针;const_cast ;reinterpret_cast;

    指针

    指针是c++中的一个核心概念,是一名c++程序员可以直接对内存进行操作的一种工具,这样的工具就是一把双刃剑,一面可以实现一些非常优化的程序,另一方面也会导致一些难以调试的错误。


    1、 使用指针遍历数组

    示例:

    #include<iostream>
    using namespace std;
    
    //使用指针遍历数组
    
    int main()
    {
    	int arr[5] = { 0, 1, 2, 3, 4 };
    	int *ptr = arr;
    	for (int i = 0;i < 5 ;i++)
    	{
    		cout << *ptr << " ";
    		ptr++;
    		//也可以直接写成 cout << *(ptr++) << " ";
    		}
    	cout << endl;
    	return 0 ;
    }
    
    

    运行结果:
    在这里插入图片描述
    示例中涉及指针的初始化、解引用操作以及自增,看一个有趣的语句“int *ptr = arr;”,该语句用数组名初始化指针。在这里数组名代表的是数组第一个元素的地址,之后在循环内程序会递增指针以指向数组的后面几个元素。


    2、指针的概念与理解

    指针(Pointer),从其英文字面上来理解就是一个指向某一物件的东西,在程序中就是指向数据的地址(Address)。计算机的内存可以看作是一个紧密排列的数据序列,每一小块数据序列,每一小块数据(也就是字节)的旁边都有一个编号代表数据地址。这在现实中可以用房屋的地址来理解,我们可以说这一栋房子是小李家,也可以说一栋房子是xx路xxx号(指针表示)。对于上面的示例可以用一个图来理解ptr 和 arr 到底指的是什么。

    arrptr
    203204205206207
    01234
    假设arr的地址是203,那么数组后面几个元素的地址依次递增(这个例子中因为数组的类型为 int ,所以 其实真是的地址需要依次增加4个字节)。指针实际上就是内存地址,所以arr的值就是203,而当ptr指向数组最后一个元素的时候,它的值为207.如果我们想要获取某一个地址下存储的数据,就可以使用ptr来获得。

    指针的含义:

    #include <iostream>
    using namespace std;
    
    //指针的含义
    
    int main()
    {
    	int arr[5] = { 0, 1, 2, 3, 4 };
    	int *ptr = arr;
    	for (int i = 0; i < 5 ; i++)
    	{
    		cout << *ptr << " ";
    		cout << "地址:" << ptr <<endl;
    		ptr++;
    	}
    	return 0 ;
    }
    
    	
    

    运行结果:
     指针代表地址
    可以看到,数组的第一个元素的十六进制地址是:0x7ffd83fdbcd0
    (不同计算机以及同一计算机每次运行该程序得到的地址都有可能与示例中的地址不同),第二个元素的地址是:0x7ffd83fdbcd4
    ,每个元素之间的距离正好是 int 的大小-----4 字节。


    3、指针的创建与初始化

    指针的创建与初始化示例:

    #include<iostream>
    using namespace std;
    
    //指针的创建和初始化
    
    int main()
    {
    	float *floatPtr = NULL;
    	string *strPtr;
    	int *intPtr1, *intPtr2;
    	int* intPtr3,  intPtr4; //intPtr4只是一个整数
           return 0 ;
    }
    
    

    通过示例可以看到,指针的声明就是在变量类型名和变量名之间加上星号(*),并可以并可以任意选择让星号紧贴类型名
    (int * intPtr3,)或者变量名
    (float *floatPtr = NULL; string *strPtr; int *intPtr1, *intPtr2;)的代码风格。然而紧贴类型名的代码风格会给人造成“int *”是一个整体的感觉,初学者很容易在声明多个指针的时候遗漏后面变量名前的星号,就像intPtr4一样,感觉像是定义了一个指针,其实只是一个整型。正确的语法是像intPtr2那样在前面加上一个星号,不管与星号之间有没有空格。

    此外,示例中只有第一样的floatPtr初始化了,但是实际编程中我们一定要初始化所有指针,就跟变量一样。floatPtr的初始值NULL是一个宏定义,它的实际数值是0,也就是地址:0x00000000.一般我们都会把指针初始化为NULL,也叫做空指针,这给我们一个统一可管理的异常值。在程序中,我们只要检查指针是否为空就知道指针是否指向有效数据了。

    **提示:**如果指针没有初始化,它可能指向一个未知的地址,那么我们在尝试读取数据的时候就可能造成程序崩溃。此外,在指针初始化的时候,不能使用0以外的整型给指针赋值。

    除了例子中的指针类型外,c++还有一种通用的void*指针。我们知道指针就是地址,指针的类型不过表示了地址指向的位置所存储的数据类型。如果我们将int * 指针转换为float * 指针,那么程序也只是将数据重新解读为浮点类型。所以这里void * 只是代表了一个地址,而我们不知道它所指向的数据类型,但我们也可以重新定义它所指向的数据类型。void * 一般会在一些内存处理的系统函数时候使用


    4、指针的基本操作

    对于指针来说,解引用和取地址是最重要的两个操作符。
    指针的基本操作

    #include<iostream>
    using namespace std;
    
    //指针的基本操作
    
    int main()
    {
    	int num = 4 ;
    	int *intPtr = &num;
    	cout << "num的地址是:" << &num << endl;
    	cout << "指针的值是:" << intPtr << endl;
    	if ( intPtr )
    	{
    		//检查指针是否为空
    		cout << "指针所指的数字是:" << *intPtr << endl;
    	}
    	return 0 ;
    }
    
    

    运算结果:
    在这里插入图片描述
    可以看到,符号“&”表示了取地址的操作,它可以获得变量的内存地址。将其赋值给我们的指针intPtr后,打印&num和intPtr将同时获得num的地址。而当我们使用解引用操作符“ * ”的时候,* intPtr将会得到intPtr所指向的地址中的数据,也就是num的值。

    在示例中,还加上了一个条件来检查指针是否为NULL,以此保证对intPtr解引用一定是安全的。这里利用了数值与布尔值之间的隐性转换,只写了intPtr作为条件,因为intPtr为空的话值会转化为false。条件intPtr也可以写成“intPtr != NULL”。
    例子中用解引用操作符读取了指针指向的数据,而解引用操作符也可以用来作为赋值语句的左值以修改为数据。

    左值解引用:

    #include <iostream>
    using namespace std;
    
    //左值解引用
    
    int main()
    {
    	int num = 4 ;
    	int *intPtr = &num;
    	if ( intPtr )
    	{
    		//检查指针是否为空
    		cout << "指针所指的数字是:" << *intPtr << endl;
    		cout << "num的值是: " << num << endl;
    		*intPtr = 3;
    		cout << "修改后,指针所指的数字是: " << *intPtr << endl;
    		cout << "num的值是:" << num << endl;
    	}
    	return 0 ;
    }
    
    

    运行结果:
    在这里插入图片描述
    示例中,使用了左值解引用操作将指向num的指针中的数据修改为3,由于指针与num的地址相同,因此num也会变成3.指针的这一种行为可能会让初学者感到困惑,接下来我们是用图片来直观地解释指针解引用、取地址和左值解引用的行为。


    5、指针的算数操作

    指针可以像整形那样进行一部分算数操作,我还可以对地址进行修改。因为计算后的指针不一定会指向具有有效数据的地址,所以在进行指针算数操作的时候需要格外小心。

    指针与整形的算数操作:

    #include<iostream>
    using namespace std;
    
    //指针与整型的算数操作
    
    int main()
    {
    	int arr[5] = { 0, 1, 2, 3, 4 };
    	int *ptr = arr;
    	cout << "arr + 4:" << *(arr + 4 ) << endl;
    	cout << "ptr + 4:" << *(ptr + 4 ) << endl;
    	cout << "ptr: " << ptr + 2 << endl;
    	cout << "++ptr: " << ++ptr << endl;
    	cout << "ptr - 2: " << ptr - 2 << endl;
    	cout << " --ptr:" << --ptr << endl;
    	return 0;
    }
    
    

    运行结果:
    在这里插入图片描述
    可以看到,指针与整型的算数操作不同于一般的数字加减,而是与指针类型绑定的。由于一个int 的大小是4字节,那么ptr+2 会将地址加上8,在组中就指向第三个元素。在示例中,除了指针ptr,我们也对数组arr做了加法,得到的结果都是第五元素的值。此外,示例末尾的ox7ffd4207fe80 已经比数组的第一个元素地址还小了,如果对这个地址进行解引用,可能会使程序崩溃。

    提示数组名其实可以看做是指向数组第一个元素的指针。指针的各种操作都适用于数组名但只有一点区别,那就是数组名不能被重新赋值。这样是很容易理解的,因为数组是静态的,数组名代表了当前作用域唯一的一个数组,不可能先指针那样指向其他地址。

    指针除了与整型的算数操作以外,还可以进行指针相减
    指针相减

    #include <iostream>
    using namespace std;
    int main()
    {
    	int arr[5] = { 0, 1, 2, 3, 4 };
    	int *ptr1 = arr + 1;
    	int *ptr2 = arr + 3;
    	cout << "ptr1:" << ptr1 << endl;
    	cout << "ptr2:" << ptr2 << endl;
    	cout << "ptr2 - ptr1: " << ptr2 - ptr1 << endl;
    	cout << "ptr1 - ptr2: " << ptr1 - ptr2 << endl;
    	return 0 ;
    }
    
    

    运行结果:
    在这里插入图片描述
    指针相减返回的是指针地址之间的距离,并且是分正负的。这个距离也与类型绑定,单位是该类型数据的个数。指针之间不存在加法,每个指针代表的地址在计算机中都是唯一确定的,相加没有任何意义。这就好像是门牌号32减掉30得到2,表示他们之间,隔着两户,而32加上30却不能表示什么。


    6、const指针

    之前有使用左值解引用来修改指针指向的原变量的例子,但如果变量是const,值是不能被修改的,因此我们也需要有一种特殊的指针来保证原变量不会被修改,这就是指向const对象的指针。

    指向const对象的指针

    #include<iostream>
    using namespace std;
    
    //指向const对象的指针
    
    int main()
    {
    	const int num = 3;
    	//普通指针不能指向const变量
    	//int *ptr1 = &num;
    	const int *ptr2 = &num;
    	cout << "*ptr2:" << *ptr2 << endl;
    	//指向const对象的指针不能修改解引用后的值
    	//*ptr2 = 4;
    	//指向const对象的指针可以修改指向的地址
    	const int num1 = 4;
    	ptr2 = &num1;
    	cout << "*ptr2: " << *ptr2 << endl;
    	//指向const对象的指针也可以指向普通变量
    	int num2 = 5;
    	ptr2 = &num2;
    	cout << "*ptr2 : " << *ptr2 << endl;
    	return 0 ;
    }
    
    

    运行结果:

    要定义一个指向const对象的指针,就要在const对象类型名后加上星号。“int* ptr1 = &num;”这一行如果去掉注释,编译器就会报错,因为普通指针不能指向const对象。“ * ptr2 =4;”这一行如果去掉注释相当于修改const对象的值,编译器也会报错。

    注意虽然ptr2指向的地址不能修改,但是它本身指向的地址可以修改。示例中,我们先后又让它指向了另外两个变量,其中也有一个非const的变量,指向非const变量的这一种指针也不能修改解引用后的值。
    既然指向const对象的指针还可以修改地址的,那么应该也有另外一种不能修改地址的指针,也就是const指针。

    const指针

    #include<iostream>
    using namespace std;
    
    //const指针
    
    int main()
    {
    	int num1 = 3 ;
    	int num2 = 4 ;
    	int *const ptr1 = &num1;
    	//const指针不能修改指向地址
    	ptr1 = &num2 ;
    	const int num3 = 5 ;
    	const int num4 = 6 ;
    	//指向const对象的const指针既不能修改地址,也不能修改值
    	const int *const ptr2 = num3;
    	ptr2 = num4;
    	return 0 ;
    }
    
    

    示例展示了尝试修改const指针而导致的编译错误。const指针的创建语法是将const移动到了星号后面,一开始ptr1指向num1,而当我们尝试把num2的地址赋值给ptr1的时候编译器报错。一个指向const对象的const指针ptr2 ,这个指针只能指向const int变量,它指向的地址也不能改变。


    7、指针的数组和数组的指针

    标题看似是两个类似的概念,二者却截然不同。指针作为一种变量类型,当然可以被声明为数组,而数组作为一种变量类型,也可以有指向它的指针。指针的数组是一种数组,而数组的指针则是一种指针。

    指针的数组和数组的指针

    #include<iostream>
    using namespace std;
    
    //指针的数组和数组的指针
    
    int main()
    {
    	int arr[5] = { 0, 1, 2, 3, 4 };
    	//数组的指针
    	int (*arrPtr)[5] = &arr;
    	//指针的数组
    	int *ptrArr[5] = { &arr[0], &arr[1], &arr[2], &arr[3], &arr[4] };
    	cout << "arrPtr: " << arrPtr << endl;
    	cout << "*arrPtr:" << *arrPtr << endl;
    	for (int i = 0; i < 5;i++)
    	{
    		cout << ( *arrPtr ) [i] << " ";
    		cout << ptrArr[i] << " ";
    		cout << *(ptrArr[i] ) << " "<< endl;
    	}
    	return 0 ;
    }
    
    

    运行结果:
    在这里插入图片描述
    可以看到,数组的指针和指针的数组的语法区别在于:数组的指针需要在星号和变量名外面加一个括号,而指针的数组却没有。这一点其实很好理解,因为声明数组的时候元素类型名int和数组大小[5] 就是被变量名隔开的,在这里我们添加一个星号,并用括号括起来,表示这个指针int( * arrPtr)[5]是指向整个数组的;如果不加括号,编译器就只会将星号联系到前面的类型名int,所以ptrArr就只是声明了一个数组,数组的元素类型就是int*。

    在声明arrPtr的时候,我们把数组的地址赋值给他作为初值,由于数组的指针解引用以后就相当于数组,我们可以用( * arrPtr)[i]来读取数组的元素。
    ptr Arr是一个指针的数组,它的每一个元素都是一个指针,这里就将数组的每个元素的地址分别赋值,而在遍历的时候使用 * (ptrArr[i])来读取数组中某一个指针指向的元素值。
    由于这里比较不直观的一点arrPtr和*arrPtr代表的地址完全一样,为了解释这一点,再看一个示例

    #include<iostream>
    using namespace std;
    
    //数组的指针的地址
    
    int main()
    {
    	int arr1[5] = { 0, 1, 2, 3, 4 };
    	//数组的指针
    	int (*arrPtr)[5] = &arr1;
    	cout <<"arrPtr: " << arrPtr << endl;
    	cout <<"*arrPtr:" << *arrPtr << endl;
    	int arr2[5] = { 0, 1, 2, 3, 6 };
    	//数组的指针必须指向大小相同的数组
    	arrPtr = &arr2;
    	cout << "arrPtr: " << arrPtr << endl;
    	cout << "*arrPtr:" << *arrPtr << endl;
    	//数组的指针指向数组,而数组是不可修改的
    	//*arrPtr = arr1
    	return 0 ;
    }
    
    

    运算结果:
    在这里插入图片描述
    我们可以看到,数组的指针必须指向相同大小的数组,如果arr2只有4个元素,“ arrPtr = &arr2; ”的赋值机会产生编译错误,并且由于数组的指针指向是不可修改的数组,我们不能把arrPtr作为左值修改。

    至于为什么arrPtr和 * arrPtr的地址一样,可以看做是编译器不得已的安排。数组名arr1代表着数组首元素的地址,而一般的变化量比如int1就放着一个数值,而&int1才放着int1 的地址。由于数组的这一特殊性,导致了&arr得到的数组地址与arr代表的数组地址是一样的,因此相应的arrPtr和 * arrPtr的地址也只能是一样的,* arrPtr也要搭配下标操作符才能取得数组的对应元素。


    8、指针的指针

    指针可以指向任何变量或者对象,所以也可以指向指针。

    #include <iostream>
    using namespace std;
    
    //指针的指针
    
    int main()
    {
    	int num = 3 ;
    	int *numPtr = &num;
    	int **numPtrPtr = &numPtr;
    	cout << "num: " << num << endl;
    	cout << "*numPtr: " << *numPtr << endl;
    	cout << "numPtr: " << numPtr << endl;
    	cout << "*numPtrPtr: " << *numPtrPtr << endl;
    	cout << "numPtrPtr: " << numPtrPtr << endl;
    	return 0;
    }
    
    

    运行结果:
    在这里插入图片描述
    可以看出,指针的指针声明就多加了一个星号,以表示指针指向的指针类型,因此将numPtr的地址赋值给它。
    指针的指针一般用于函数传参数时修改传入的指针。


    9、const_cast 与reinterpret_cast

    const_cast的作用是将一个变量转换成const限定的常量。

    const_cast

    #include<iostream>
    using namespace std;
    
    //const_cast
    
    int main()
    {
    	int intNum = 2 ;
    	intNum = 3;
    	//const_cast后面必须跟引用或指针类型
    	const int &consIntNum = const_cast<int&>(intNum);
    	//转换以后数字不能在修改
    	//constIntNum = 2;
    	return 0 ;
    }
    
    

    示例中,可以看到intNum在转换前是可以修改的变量,在转换以后就变成常量,不能再进行修改了。

    reinterpret_cast 比较特殊。reinterpret 的意思是重新解读,而reinterpret_cast 就是将一段数据按照二进制表示重新解读成另一种数据,所以他并没有对数据做任何改变,只是改变了类型。

    reinterpret_cast

    #include<iostream>
    using namespace std;
    
    //reinterpret_cast
    
    int main()
    {
    	int intNum = 0x00646362;
    	int *intPtr = &intNum;
    	char *str = reinterpret_cast<char *>(intPtr);
    	cout << "str的值为:" << str << endl;
    	return 0;
    }
    
    

    运行结果:
    在这里插入图片描述
    在示例中,可以看到热interpret_cast将一个指向整数的指针转换成了指向字符的指针,也就是c风格的字符串,十六进制的62、63、64在ASCLL码中分别代表b、c、d,所以打印了“bcd”。
    reinterpret_cast 的作用就是将一个类型的指针转换成另一个类型的指针,而指针指向的内存将被原封不动地重新解读。当然这也是一种比较危险的举动。

    如果本文对您有帮助,请点赞支持一下~

    展开全文
  • C++ 指针和引用

    千次阅读 2021-01-17 22:54:20
    C++ 指针和引用C++ 指针和引用1. 指针和引用的区别2. 指针3. 引用4. 引用&&指针 作为参数4.1. 常引用5. 把引用&&指针 作为返回值6. 引用&&指针 实现多态 1. 指针和引用的区别   很多情况...
  • C++ 指针

    千次阅读 多人点赞 2021-05-03 10:51:12
    C++ 指针介绍 (对象指针 & this 指针)
  • c++指针最全总结(附源码详细总结)

    千次阅读 多人点赞 2022-04-08 13:44:03
    哈喽,我又来啦 hello 我是「 YR_T 」 众所周知 c++相对于其它语言的 ...优势就在与c++有「 指针 」 可能你之前有学习过指针 可是 你真的把指针彻底搞懂了吗 如果还没有,那再来复习一下 ...
  • 【小白学习C++ 教程】十、C++指针和内存分配

    千次阅读 多人点赞 2021-06-20 07:32:54
    //声明变量p和指针变量ptr p = 4; //赋值4给变量p ptr = &p; //将p的地址分配给指针变量ptr 在内存中,这些声明将表示如下: 这是指针在内存中的内部表示。当地址变量分配给指针变量时,它指向的变量如上图所...
  • C++ 打印指针

    千次阅读 2021-10-12 09:58:42
    //这样输出的就是指针的值 cout<<*p; //指针的值里存储的东西。。 但是有字符比较特殊,需要使用下面的方案 #include <iostream> using namespace std; int main() { char * ptr = "abc" ; ...
  • c++ 指针指针参数

    千次阅读 2021-05-10 13:12:00
    首先,当指针作为形参时,实参向形参传递的是地址,在函数执行过程中既可以对指针变量进行操作也可以对指针所指数据进行操作(即P*P).由于形参实参指向同一个内存单元,当形参指向的数据改变那么实参所指向的数据也...
  • 主要辨析一下C/C++中指针相关常见概念。 首先理解指针所指向元素与指针,他的意思就相当于地图上你家的位置与你家里的实际情况。知道了**指针**(地图上的位置),就可以知道怎么去你家,但是无法知道你家中的具体...
  • C++输出字符型指针地址

    千次阅读 2020-10-21 16:02:25
    因此,我们用static_cast强制类型转换把字符串指针转换成无类型指针即可输出指针地址 #include<iostream> using namespace std; int main() { char *p="abc"; cout << p << endl;//"abc" ...
  • C++的函数传指针和地址区别

    千次阅读 2020-05-26 22:23:52
    C++的函数传指针和地址区别 本人的第五篇文章,才疏学浅,讲的东西很浅薄,有错误希望有同学指出。 学了的C++一系列基础之后,套用一些东西麻木可能使得思维变得麻木,回头看的时候一些东西觉得的确该这么写,但...
  • C++指针偏移原理

    千次阅读 2021-08-17 19:26:36
    C++中我们可以通过指针方便的访问各种类型数据,但我们都知道指针只是一个头地址,而我们需要遍历的数据通常占有大量的空间,那么指针是如何遍历其中的数据呢?这就涉及到指针偏移的一个问题,下面我们看个例子: ...
  • C++指针详解

    万次阅读 多人点赞 2018-12-08 22:55:09
    有好的一面,必然会有坏的一面,指针的灵活导致了它的难以控制,所以C/C++程序员的很多bug是基于指针问题上的。今天就对指针进行详细的整理。 1、指针是什么? 指针是“指向(point to)”另外一种类型的复合类型...
  • c++智能指针详解

    千次阅读 多人点赞 2022-05-18 17:48:58
    1.什么是智能指针 从比较简单的层面来看,...在c++中,智能指针一共定义了4种: auto_ptr、unique_ptr、shared_ptr weak_ptr。其中,auto_ptr 在 C++11已被摒弃,在C++17中已经移除不可用。 2.原始指针的问题 原始指
  • C++指针和New 、delete的使用

    千次阅读 2018-12-27 14:46:47
    1.指针的使用赋值 #include using namespace std; int main() { int a=10; int *p=&amp;a;//指针赋值,把a的地址赋值给p cout &lt;&lt; a &lt;&lt; endl; cout &lt;&lt; *p &lt;&...
  • 指针和引用的区别 对于指针来说,它是一个地址,这个地址是一个数值,那么就意味这个数值可以为0(空指针),也可以为其他,即指针可以不指向任何东西。 而对于引用来说,他是一个外号,外号一定是“某个存在物体”...
  • 二级指针指针指针) 3.1 定义与初始化 3.2间接数据访问 3.2.1.改变一级指针指向 3.2.2改变 N-1 级指针的指向 3.2.3二级指针的步长 四. 指针与数组 4.1 指针与数组名 4.1.1 通过数组名访问数组元素 4.....
  • C++内存逻辑二:指针地址

    千次阅读 2021-01-25 11:28:13
    指针创建删除后的地址详解
  • C/C++指针与内存管理

    千次阅读 2021-09-06 23:12:36
    指针 1.1 变量与内存的关系 首先来我们来看计算机内存的示意图,大致分成这几个区,每个区又分成一块块的小方格,那就是字节。 当我们写下,int a; 的时候,IDE会向系统在栈区申请一块4个字节的内存, 二.数组 三....
  • c++数组指针和指针数组详解

    万次阅读 多人点赞 2019-03-14 15:33:16
    数组指针可以说成是”数组的指针”,首先这个变量是一个指针,其次,”数组”修饰这个指针,意思是说这个指针存放着一个数组的首地址,或者说这个指针指向一个数组的首地址指针数组 首先先定义一个指针数组,既然...
  • 练习题:C++指针练习

    千次阅读 2020-09-24 13:59:24
    C++中,const作用域指针时,可以看做是对指针权限的限制。这里我们先把指针的权限归为两种,分别为指向权限修改权限。(ps:以上是为了理解方便,实际并没有如此规定) int a = 10, b = 20; int* p = &a; ...
  • C++指针的作用

    千次阅读 2020-09-08 17:13:38
    利用指针就可以使用地址作为一个完整值的速记符号,因为一个内存地址在内部表示为一个整数。当数据结构本身很大时,这种策略能节约大量内存空间 2.指针使程序的不同部分能够共享数据 类似于共享内存,如果将某一个...
  • C++指针详细讲解

    千次阅读 多人点赞 2020-02-04 22:57:37
    详细讲解C++指针的原理以及应用,附加代码样例。
  • C++ 指针详解(转)

    千次阅读 2020-08-04 08:45:09
    (3) 使用指针存储地址 (4) 使用 * 访问指向的数据 2. 动态内存分配 (1) new/delete动态分配释放内存 (2) 带关键字const的指针 (3) 指针 VS 数组 3. 使用指针时的常见错误 (1) 内存泄漏 (2) 无效...
  • C++函数指针用法

    千次阅读 2022-01-06 00:25:41
    C++函数指针详细理解 函数指针初识 函数指针是指向函数的指针,并不等于函数,它能够执行函数的操作,可以跟指针变量一起来理解,其基本声明格式为: type (*ptrname)(形参列表); 例子,声明一个比较两个字符串大小的...
  • C++指针和智能指针

    千次阅读 2019-12-07 12:11:54
    C++指针和智能指针裸指针的缺陷及实例演示忘记释放指针指向的资源代码逻辑过早结束 导致释放资源的代码执行不到代码运行过程中,代码发生异常了,直接出当前函数栈帧了通过裸指针,访问对象时,无法判断对象是否...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 778,092
精华内容 311,236
关键字:

c++指针和地址

c++ 订阅