精华内容
下载资源
问答
  • 1. C语言指针变量 : 类型名 *指针变量名 char *pa; //定义一个指向字符型的指针变量 int *pb; // 定义一个指向整型的指针变量 2 . 取值运算符和取地址运算符 (1) 如果需要获取某个变量的地址,可以使用取地址...

    1. C语言指针变量 : 类型名  *指针变量名

    char  *pa;  //定义一个指向字符型的指针变量

    int  *pb; // 定义一个指向整型的指针变量

    2 . 取值运算符和取地址运算符

    (1) 如果需要获取某个变量的地址,可以使用取地址运算符&。

    char *pa = &a;

    int *pb = &b;

    (2) 如果需要访问指针变量指向的数据,可以使用取值运算符*

    printf("%c,%d\n",*pa,*pb)

     注意: 避免访问为初始化的指针

    
    #include <stdio.h>
    
    int main()
    
    {
           char a = 'F';
           int f = 123;
    
           char *pa = &a;
           int *pb = &b;
     
           printf("a = %c\n", *pa);
           printf("f = %d\n", *pb);
    
           *pa = 'C';
           *pb +=1;
    
           printf("now,a = %c\n", *pa);
           printf("now,f = %d\n", *pb);
    
           return 0; 
    
    }
    

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 1. C语言指针变量: 类型名 *指针变量名 char *pa; //定义一个指向字符型的指针变量 int *pb; //定义一个指向整型的指针变量 2 . 取值运算符和取地址运算符 (1) 如果需要获取某个变量的地址,可以使用取地址...

    1. C语言指针变量 : 类型名  *指针变量名

    char  *pa;  //定义一个指向字符型的指针变量

    int  *pb; // 定义一个指向整型的指针变量

    2 . 取值运算符和取地址运算符

    (1) 如果需要获取某个变量的地址,可以使用取地址运算符&。

    char *pa = &a;

    int *pb = &b;

    (2) 如果需要访问指针变量指向的数据,可以使用取值运算符*

    printf("%c,%d\n",*pa,*pb)

     注意: 避免访问为初始化的指针

    #include <stdio.h>
    
    int main()
    {
           char a = 'F';
           int f = 123;
    
           char *pa = &a;
           int *pb = &b;
    
           printf("a = %c\n", *pa);
           printf("f = %d\n", *pb);
    
           *pa = 'C';
           *pb +=1;
    
           printf("now,a = %c\n", *pa);
           printf("now,f = %d\n", *pb);
    
           return 0;
    
    }

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • c++ 取地址运算 指针变量

    千次阅读 2013-08-08 10:56:22
    一、取地址运算符&(内存地址) C++编译的程序占用的内存分为以下几个部分: 1.栈区:由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。与其它分区不同,变量的...

    一、取地址运算符&(内存地址)

    C++编译的程序占用的内存分为以下几个部分:

    1.栈区:由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。与其它分区不同,变量的地址是按照申请顺序降序排列的。

    2.堆区: 由new指令申请,由delete指令释放。申请后不释放可能会造成内存资源的浪费。需要指出,对于用指针申请的对内存空间,指针本身存入栈,指针指向的空间则存储在堆中。

    3.全局(静态)变量区:全局变量和静态(由static修饰)变量的存储是放在一块的。从程序开始运行时写入变量值,运行结束前释放变量。

    4.程序代码区:用于存放函数体的二进制代码。

    另外,还有专门用于存放常量的区域。

    下面编写程序进行测试,证明以上几种变量分区不同。

    ?
    #include <iostream>
    using namespace std;
    int x,y,z;
     
    void f1(){};
    void f2(){};
     
    void main()
    {
        int a,b,c;
        cout<<"局部变量的地址:"<<endl;
        cout<<&a<<" "<<&b<<" "<<&c<<endl;//地址降序
     
        int *m = new int[3], *n = new int, *l = new int, *k = new int;
        cout<<"指针所指向的内存的地址:"<<endl;
        cout << &(*n) << " " << &(*l) << " " << &(*k) << endl;//指针本身存入栈,地址降序
        cout<<"指针指向空间的地址:"<<endl;
        cout <<&(m[0])<< " " <<&(m[1])<< " " <<&(m[2])<< endl;
     
        static int w;
        cout<<"全局(局部)变量的地址:"<<endl;
        cout<<&x<<" "<<&y<<" "<<&z<</*" "<<&w<<*/endl;
     
        cout<<"函数代码的地址:"<<endl;
        cout<<&main<<" "<<&f1<<" "<<&f2<<endl;
    }

    程序运行结果:

    clip_image002

    由程序运行结果可以看出:

    1. 四种变量的地址相互相差很大,而本身相差很小,说明被分配在了不同的内存空间。

    2. 指针和变量的地址是降序排列的,说明被分配在了栈区。

    3. 全局变量和局部变量的地址相邻,说明二者被安排在了同一分区。

    注意:不要把取地址运算符&和应用运算符&搞混,前者放在变量定义中的变量的前面,而后者放在函数原型定义中的类型名后面。

    二、指针变量

    我们要想更好的利用上面提到的地址,就必须设定一个变量来保存地址。像用变量来保存int、float等类型的值一样,地址也可以用类似的方法保存。

    定义:用来保存地址的变量叫做指针变量(pointer variable)或者简称指针。

    如:int* ptr;星号表示指向谁,这个声明定义了一个指向整型数据的指针变量。这个变量中保存整型数据的地址:ptr=&variable;

    1) 访问指针指向的变量。

    *ptr就表示了ptr中的地址上存储的值。变量名前面的星号表示间接引用运算符(dereference operator)或者叫做取内容运算符(contents operator)。

    2)void指针

    指针保存的变量必须和指针的类型保持一致,如不能将一个float类型的地址赋给一个指向int的指针。

    ?
    float flovar=98.6;
    int* ptr=&flovar;  //错误:不能将一个float类型的地址赋给一个指向int的指针

    但是有一个通用的指针可指向任何数据类型,这类指针成为void:如void* ptr;

    三、指针和数组

    首先来看看数组表示法和指针表示法访问同一数组元素:

    ?
    #include <iostream>
    using namespace std;
    int main()
    {
        int intarray[5]={31,54,36,47,38};
        for (int j=0;j<5;j++)
        {
            cout<<intarray[j]<<endl   //数组表示法
                <<*(intarray+j)<<endl;//指针表示法
        }
        return 0;
    }

    指针表示法:数组名就是数组的首地址,在这里+j就是数组第j+1个元素的地址。再加上取内容运算符*就得到了地址上储存的数据了。

    考虑:为什么系统能知道+j就跳到j+1个元素的地址呢,在这里地址明明四个字节四个字节的增长的?

    答:还记得前面讨论void指针的时候说的吗,在指针说明的时候必须包含指针所指向的数据类型,因为编译器要知道一个指针是int类型的还是float类型的,这样它才能在访问数组元素的时候执行真确的算术运算。

    1) 指针常量和指针变量

    表达式intarray是系统分给数组空间的首地址,数组将一直保持着这个地址知道程序结束。intarray是一个指针常量,不能进行++或者--运算,就和不能说7++一样。只有变量才可以进行这样的运算。

    四、指针和函数

    1)首先,同样进行引用传递参数和指针传递参数的对比:

    ?
    #include <iostream>
    using namespace std;
    void funcref(double&);
    void funcptr(double*);
    int main()
    {
        double var=10.0;
        cout<<"前var="<<var<<endl;
        funcref(var);
        cout<<"引用var="<<var<<endl;
        funcptr(&var);
        cout<<"指针var="<<var<<endl;
        return 0;
    }
    void funcref(double& v)
    {
        v *= 3.14;
    }
    void funcptr(double* ptr)
    {
        *ptr*=2;
    }

    在这里,指针作为参数和应用一样,他传递的不是变量本身,而是变量的地址。(引用是原始变量的一个别名,指针是原始变量的地址)

    因为ptr中包含的是var的地址,所以任何对*ptr的操作实际上都是对var的操作。

    2)排序数组元素

    冒泡法排序:

    ?
    #include<iostream>
    using namespace std;
    int main()
    {
        void order(int*,int);
        const int N=10;
        int array[N]={1,3,234,23,54,656,76,878,87,57};
        cout<<"比较前:";
        for(int j=0;j<N;j++)
            cout<<*(array+j)<<" ";
        order(array,N);
        cout<<"\n比较后:";
        for(int j=0;j<N;j++)
            cout<<*(array+j)<<" ";
        cout<<endl;
        return 0;
    }
    void order(int* ptr,int n)
    {
        void bijiao(int*,int*);
        for (int j=0;j<n-1;j++)
        {
            for (int i=j+1;i<n;i++)
            {
                bijiao(ptr+j,ptr+i);
            }
        }
    }
    void bijiao(int* m,int* n)
    {
        int tem;
        if (*m>*n)
        {
            tem=*m;
            *m=*n;
            *n=tem;
        }
    }

    五、指针和C类型字符串

    1)字符串常量指针:char str1[]=”Defined as an array”;(c类型字符串)

                                   char* str2=”Defined as an array”;(指针类型字符串)

    2)看个程序:

    ?
    #include<iostream>
    using namespace std;
    int main()
    {
        void copystr(char*,const char*);
        char* str1="hah is hahah!";
        char str2[80];
        copystr(str2,str1);
        cout<<str2<<endl;
        return 0;
    }
    void copystr(char* dest,const char* src)
    {
        while (*src)
        {
            *dest++=*src++;
        }
        *dest='\0';
    }

    ※注意※=====const的使用================================================ 
    (http://bbs.chinaunix.net/viewthread.php?tid=683333&extra=&page=1) 
    关键问题点:const 属于修饰符 ,关键是看const 修饰的位置在那里 
    1、const int *a 
    这里const 修饰的是int,而int定义的是一个整值 
    因此*a 所指向的对象 值 不能通过 *a 来修改,但是 可以重新给 a 来赋值,使其指向不同的对象 
    eg: 
      const int *a = 0; 
      const int b = 1; 
      int c = 1; 
      a = &b //ok! 额外:注意不能通过a 来修改 b值 
      a = &c //ok! 额外:虽然c本身不是一个常量 
      *a = 2 //erro! 为题就在这里,不能修改通过 *a 所指向的对象值,最后赋值得对象是c,因此不能通过*a 来修改c值。 
    2、int *const a   
    这里const修饰的是 a ,a代表的是一个指针地址 
    因此不能赋给a其他的地址值,但可以修改a指向的值 
    这有点和cont int *a相反的意味,例子就不说了 
    3、至于int const *a 和 const int *a 的意义是相同的 他们两个的作用等价 
    补充: 
    4、const int * const a  
    这个代表a所指向的对象的值以及它的地址本身都不能被改变 
    5.const int a = 10 和 int const a = 10有什么区别? 
    这应该没区别,指针的话有区别  
    对指针来说,可以指定指针本身为const,也可以指定指针所指的数据为const,或二者同时指定为const。 
    关于const的点滴补充: 
    1、const 对象的地址只能赋值给指向const 对象的指针 
    2、指向const 对象的指针可以 被赋 以 一个非const 对象的地址  
    3、指向const 的指针常被用作函数的形式参数,保证被传递给函数的实际对象在函数得实际对象在函数中不会被修改 
    4、常量在定义后就不能被修改,所以它必须被初始化。未初始化的常量定义将导致编译错误(上面都是在说明const得问题,所以没有赋值,实际语句中要赋值的)

    3)指针数组和数组指针

    ==================指针数组,数组指针================================== 
    对于理解指针数组和数组指针也比较有用,如: 
    --------------指针数组(首先是个数组)-------------------- 
    int *p[10];//指针数组,含有10个指针元素  
    也就是说每一个元素都是指针。先是解析[]表示它是一个数组,然后*表示指针,int表示为int型指针,即表示定义一个指针数组,含有10个int类型指针元素。 
    --------------数组指针(首先是个指针)-------------------- 
    int (*p)[10];//数组指针,这个指针能够用来指向含有10个元素的整数数组。 
    先是解析(),括号里表示这个是个指针,然后[]表示数组,即表示定义了一个指向数组的指针。数组指针。

    展开全文
  • 类似于C/C++中令一个指针指向一个变量地址,通过解引用可以得到变量的值。利用ctypes模块在Python中实现类似的功能: import ctypes value='hello world' #定义一个字符串变量address=id(value) #获取va...

    类似于C/C++中令一个指针指向一个变量的地址,通过解引用可以得到变量的值。利用ctypes模块在Python中实现类似的功能:

    import ctypes
     
    value='hello world' #定义一个字符串变量
    address=id(value) #获取value的地址,赋给address
    get_value=ctypes.cast(address, ctypes.py_object).value #读取地址中的变量
    print(get_value)
    
    # 结果:
    hello world
    
    展开全文
  • 指针变量与变量地址

    千次阅读 2017-06-19 15:12:49
    一、基本概念 ...变量的名字对应着存储单元的地址变量内容对应着单元所存储的数据。存储地址一般用十六进制数表示,而每一个存储器地址中又存放着一组二进制(或十六进制)表示的数,通常称为该地址的内容。
  • C语言学习(2):指针变量地址

    千次阅读 2018-04-19 23:31:01
    前言 指针其实很简单。同C语言中其他变量一样,把指针也看成是一种变量即可,...本文主要讲利用指针变量如何读写地址中的值。 正文 1、首先来假设一个场景:交换a和b两个变量的值。看下面的例子: void sw...
  • 指针:  ...比如通过我的抽屉里放了一支笔,这支笔就是变量,我的抽屉就是存放变量地址,也就是指针。还比如地址2000是变量i的储存单元,那么根据地址2000我们就可以访问地址为2000的变量i,2000就
  • i)就是一个C语言的函数,我们已经试过在scanf内将地址交给一个整数,但是整数和地址不见得总是类型一致,那么什么样的类型可以接受取地址得到的地址呢?那就是指针! 一、指针的定义 指针类型的变量就是保存地址的...
  • 指针与指针变量

    千次阅读 2019-05-09 16:00:16
    对变量的访问都是通过地址进行的 访问方式: 1.直接访问:按照变量名进行访问。 2.间接访问:将一个变量的存放在另一个变量中,然后通过该变量来找到之前变量地址,进而访问之前的变量。 ...
  • 指针及指针变量

    千次阅读 2018-05-26 19:40:08
    本篇博客就介绍指针和指针变量的相关定义知识。&amp;a就是得到a的地址,其实“指针==地址”,int *p就是定义一个整型地址(指针)变量int a=10;//整型变量存放整型值double b=1.24;//浮点型变量存放浮点型值int ...
  • 指针变量的运算

    千次阅读 2015-08-24 10:42:47
    指针变量的运算  指针变量可以进行某些运算,但其运算的种类是有限的。 它只能进行赋值运算和部分算术运算及关系运算。 1.指针运算符(1)取地址运算符&  取地址运算符&是单目运算符,其结合性为自右至左,其功能...
  • 指针,地址指针变量之间的区别和联系

    万次阅读 多人点赞 2018-03-24 17:39:57
    但是指针的概念比较抽象,难于理解,而且一些复杂的程序中都是离不开指针的,如果不能理解指针,那么就不能理解较为复杂的程序了,作者结合了自己学习C++的经验,指针,指针变量地址作如下阐述。1.什么是指针:...
  • 指针和指针变量的关系

    千次阅读 多人点赞 2017-02-20 22:51:06
    指针就是地址地址就是指针。 地址就是内存单元的编号。 指针变量就是存放内存地址的变量。
  • C语言中指针取地址符&详解

    千次阅读 2019-10-31 22:19:27
    关于指针与取地址符 1.什么是指针? (1)首先,我们要明白什么叫做指针变量名,对于 int *p,这里的指针变量名不是 p 而是 p ,类似与 Java 中定义数组是 int [] array ,所以我习惯将 p 叫做 int * 类型 (2)通俗的...
  • 1.指针变量的值。指的是P本身的值,写作P,在这里是a的地址,类型为int型; 2.指针地址的值,指的是p的地址值,写作&amp;p,这个地址代表的内存,存储出是P的值,类型为**型,也就是二级指针; 3.指针指向的值,...
  • 指针变量的初始化

    千次阅读 2019-05-14 20:03:35
    那么怎么给一个指针变量初始化呢?即怎么样使一个指针变量指向另一个变量呢?上面的程序实际上已经使用了,即可以用赋值语句使一个指针变量得到另一个变量的地址,从而使他指向该... 是“取地址运算符”,与 scanf...
  • 1、 指针变量的值(指针的值),指的是p本身的值,写作p, 在这里是变量a的地址,类型为int *型 2、 指针地址的值,指的是p的地址值,写作&amp;amp;amp;amp;p, 这个地址代表的内存,存储的是p的值,类型为int **...
  • C++引用 ...引用就是某一变量(目标)的一个别名,引用的操作与对变量直接操作完全一样。引用的声明方法:类型标识符 &引用名=目标变量名; (1)&在此不是求地址运算,而是起标识作...
  • 指针=变量的地址指针变量则是存放变量地址的变量。所以要说指针变量,它的首要概念应该是:它本身是一个变量,然后再去理解他的行为与实现。示例: int a=10; void *b; b=&a; printf("%p/n",b); // *b=20;
  • 1.golang中,指针是一种类型,指向变量所在的内存单元(不是内存地址)。 申明: 在变量名前加上星号字符,比如 *age ,指向变量age所在的内存单元 2.& :获取变量在计算机内存中的地址, &age,取出变量...
  • 指针取地址

    千次阅读 2017-03-18 21:13:09
    指针的几个注意点 首先要明白指针的变量名是什么,如int *p;它的变量名是p而不是*p; 指针一定是只能保存地址,而保存...表示的是定义一个指针变量,而后面操作时*p = 10;表示的是去操作指针指向的那个地址的内容
  • package main import "fmt" // & * func main() { a:=100 fmt.Println("a的地址:",&a) var ptr *int=&a fmt.Println("ptr指向的值是:",*ptr) }
  • 但是指针的概念比较抽象,难于理解,而且一些复杂的程序中都是离不开指针的,如果不能理解指针,那么就不能理解较为复杂的程序了,作者结合了自己学习C++的经验,指针,指针变量地址作如下阐述。 1.什么是指针...
  • c语言与指针——(二)指针变量的定义与赋值

    万次阅读 多人点赞 2017-12-14 18:15:52
    由上一节,我们知道了,指针就是地址,而变量的指针就是变量的地址,存放变量地址的变量就是指针变量指针变量可以指向另一个变量,在程序中使用" * "来表示这种指向关系。 1.指针变量的定义  指针的定义依然遵循...
  • C 指针变量值和地址传递

    千次阅读 2018-06-25 16:46:53
    //指针变量进行值传递,实参赋值给形参,会在栈区申请一个局部的指针变量,和外面实参是两个... } 使用指针变量地址作为参数传入函数,函数中申请的空间的地址会赋值str和临时变量*p,释放时会释放同一块内存空间;
  • &(取地址运算符) i_pointer=&i; 什么是指针指针就是存放内存地址的变量。 一个变量的地址称为该变量指针。 作用是什么? 指向一个已经存在的同类型的变量 指向的意思,就是可以用这个指针代替原始的变量名进行...
  • C语言指针变量的自增自减分析(指针的算数运算)

    千次阅读 多人点赞 2018-09-08 16:19:29
    前言 ...2. 指针变量地址指针变量的加减是地址的加减, 举例说明: 假设:整型指针变量p指向整型数组a的首元素;(p = a) 分析: 1) p++; //p自加,使自己指向先一个元素a[1] 2)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 259,400
精华内容 103,760
关键字:

对指针变量取地址