初识C++ 的 this ,引用 的区别

    在说明问题之前,先回顾在C语言中,一个对象怎么调用对象本身里的成员。又回顾到了以前TOM请lucy吃饭的问题:

 一 .this 指针   

  1 #include<stdio.h>
  2
  3 struct person
  4 {
  5     char* name;
  6     void (*fp)(struct person* t);
  7     char* gf;
  8
  9 };
 10
 11 void hello(struct person* t);
 12
 13 int main()
 14 {
 15     struct person tom;
 16     tom.name = "tom";
 17     tom.gf = "lucy";
 18     tom.fp = hello;
 19     tom.fp(&tom);
 20
 21     struct person songchengyi;
 22     songchengyi.name = "songchengyi";
 23     songchengyi.gf = "pengpeng";
 24     songchengyi.fp=hello;
 25     hello(&songchengyi);
 26 }
 27
 28
 29
 30
 31 void hello(struct person* t)
 32 {
 33     printf("%s please %s eat! \n",t->name,t->gf);
 34 }
 35 

    为了方便地请吃饭,我们引用了一个函数指针来指向hello,在C++中,类似于hello的操作叫做方法;

   而结构体struct person叫做类;

   在21行 struct person tom这句叫做实例化一个对象,tom就叫做对象;

   为了方便地调用到类自身里面的参数,我们定义了一个struct person* t,当调用方法时候就可以方便地调用本身的参数;

 

   而在C++中,一个对象的this指针并不是对象本身的一部分,不会影响sizeof(对象)的结果。this作用域是在类内部,当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说,即使你没有写上this指针,编译器在编译的时候也是加上this的,它作为非静态成员函数的隐含形参,对各成员的访问均通过this进行

    

  1 #include <iostream>
  2
  3 using namespace std;
  4
  5 struct person
  6 {
  7     char* name;
  8     char* gf;
  9     void hello();
 10 };
 11
 12 int main()
 13 {
 14     struct person tom;
 15     tom.name = "tom";
 16     tom.gf = "lucy";
 17     tom.hello();
 18 }
 19
 20
 21 void person::hello()
 22 {
 23
 24     cout<< this->name  << " please " << this->gf <<" eat " << endl;
 25
 26 }
 27
 28
~                 

    

   二 .引用,引用很像C语言中的指针,但是,C++中的引用和C语言的指针却有着明显的区别:

    1,引用是为了指向同一块内存,只是名字不同而已;而指针是一个存放地址的变量;

    2,指针可以不初始化,而引用必须要初始化;

    。。。。(还有,以后补充)

    

  1 #include <iostream>
  2
  3 using namespace std;
  4
  5 void hello(int &j);
  6
  7 int main()
  8 {
  9     int i=5;
 10     int *p = &i;
 11     int &j =i;//引用 j 为 i的地址;
 12
 13     hello(j);
 14
 15     cout << " j is"<< j << endl;
 16 }
 17
 18
 19 void hello(int &j)
 20 {
 21      j = 30;
 22
 23 }
 24
 25
~            

    引用是C++特有的。

   

    

时间: 2024-11-08 18:23:49

初识C++ 的 this ,引用 的区别的相关文章

指针与引用的区别以及引用的三种用法

1.指针与引用的区别: 指针是一块内存的地址值,而引用是一块内存的别名. 下面引自:http://www.cnblogs.com/kingln/articles/1129114.html 从概念上讲.指针从本质上讲就是存放变量地址的一个变量,在逻辑上是独立的,它可以被改变,包括其所指向的地址的改变和其指向的地址中所存放的数据的改变. 而引用是一个别名,它在逻辑上不是独立的,它的存在具有依附性,所以引用必须在一开始就被初始化,而且其引用的对象在其整个生命周期中是不能被改变的(自始至终只能依附于同一

转 浅谈C++中指针和引用的区别

浅谈C++中指针和引用的区别 浅谈C++中指针和引用的区别 指针和引用在C++中很常用,但是对于它们之间的区别很多初学者都不是太熟悉,下面来谈谈他们2者之间的区别和用法. 1.指针和引用的定义和性质区别: (1)指针:指针是一个变量,只不过这个变量存储的是一个地址,指向内存的一个存储单元:而引用跟原来的变量实质上是同一个东西,只不过是原变量的一个别名而已.如: int a=1;int *p=&a; int a=1;int &b=a; 上面定义了一个整形变量和一个指针变量p,该指针变量指向a

C++中指针和引用的区别

此文转自:http://www.cnblogs.com/kingln/articles/1129114.html 从概念上讲.指针从本质上讲就是存放变量地址的一个变量,在逻辑上是独立的,它可以被改变,包括其所指向的地址的改变和其指向的地址中所存放的数据的改变. 而引用是一个别名,它在逻辑上不是独立的,它的存在具有依附性,所以引用必须在一开始就被初始化,而且其引用的对象在其整个生命周期中是不能被改变的(自始至终只能依附于同一个变量). 在C++中,指针和引用经常用于函数的参数传递,然而,指针传递参

编程题:指针变量,直接引用和间接引用的区别。

#include<stdio.h> void main() { int a,b; int *p;   /*定义指针变量p*/ p=&b;     /*将变量b的地址放在变量p中*/ a=3;      /*直接引用变量a*/ *p=5;     /* 间接引用变量b*/ printf("a=%d,b=%d\n",a,b); } 编程题:指针变量,直接引用和间接引用的区别.,布布扣,bubuko.com

C++ 中指针与引用的区别

指向不同类型的指针的区别在于指针类型可以知道编译器解释某个特定地址(指针指向的地址)中的内存内容及大小,而void*指针则只表示一个内存地址,编译器不能通过该指针所指向对象的类型和大小,因此想要通过void*指针操作对象必须进行类型转化.     ★ 相同点: 1. 都是地址的概念: 指针指向一块内存,它的内容是所指内存的地址: 引用是某块内存的别名.     ★ 区别: 1. 指针是一个实体,而引用仅是个别名: 2. 引用使用时无需解引用(*),指针需要解引用: 3. 引用只能在定义时被初始化

指针与引用的区别和联系

指针与引用的区别: The difference between "pointer" and "reference" 区别1: 给指针A赋值的时侯,要么赋一个地址B,要么赋一个同类型的指针C ( 使用地址B赋值时,B中存储的值的类型要和A指针指向的类型一致.如果B指向的值用const 修饰,那么指针A在初始化时,最外面也要用const 修饰 使用指针C赋值时,如果指针C最外面使用const 修饰,如 const int * C  OR  const int * co

C++小知识:指针和引用的区别

从概念上讲.指针从本质上讲就是存放变量地址的一个变量,在逻辑上是独立的,它可以被改变,包括其所指向的地址的改变和其指向的地址中所存放的数据的改变.    而引用是一个别名,它在逻辑上不是独立的,它的存在具有依附性,所以引用必须在一开始就被初始化,而且其引用的对象在其整个生命周期中是不能被改变的(自始至终只能依附于同一个变量). 在C++中,指针和引用经常用于函数的参数传递,然而,指针传递参数和引用传递参数是有本质上的不同的:     指针传递参数本质上是值传递的方式,它所传递的是一个地址值.值传

向函数中传递指针和传递指针的引用的区别

如果是传递指针,那么会先复制该指针,在函数内部使用的是复制后的指针,这个指针与原来的指针指向相同的地址,如果在函数内部将复制后的指针指向了另外的新的对象,那么不会影响原有的指针:但 是对于传递指针应用,如果将传递进来的指针指向了新的对象,那么原始的指针也就指向了新的对象,这样就会造成内存泄漏,因为原来指针指向的地方已经不能再 引用了,即使没有将传递进来的指针指向新的对象,而是在函数结束的时候释放了指针,那么在函数外部就不能再使用原有的指针了,因为原来的内存已经被释放了 看个例子: #includ

指针和引用的区别(c/c++)

http://blog.csdn.net/thisispan/article/details/7456169 ★ 相同点: 1. 都是地址的概念: 指针指向一块内存,它的内容是所指内存的地址:引用是某块内存的别名.  ★ 区别: 1. 指针是一个实体,而引用仅是个别名: 2. 引用使用时无需解引用(*),指针需要解引用: 3. 引用只能在定义时被初始化一次,之后不可变:指针可变: 引用"从一而终" ^_^ 4. 引用没有 const,指针有 const,const 的指针不可变: 5.

【转】指针和引用的区别

c++中的引用与指针的区别 ★ 相同点: 1. 都是地址的概念: 指针指向一块内存,它的内容是所指内存的地址:引用是某块内存的别名. ★ 区别: 1. 指针是一个实体,而引用仅是个别名: 2. 引用使用时无需解引用(*),指针需要解引用: 3. 引用只能在定义时被初始化一次,之后不可变:指针可变: 引用“从一而终” ^_^ 4. 引用没有 const,指针有 const,const 的指针不可变: 5. 引用不能为空,指针可以为空: 6. “sizeof 引用”得到的是所指向的变量(对象)的大小