C++中的对象指针总结_C 语言

指向对象的指针
在建立对象的时候,变异系统会给每一个对象分配一定的存储空间,以存放其成员。
对象空间的起始地址就是对象的指针。可以定义一个指针变量,用来存放对象的指针。

一个简单的示例1.1:

复制代码 代码如下:

#include<iostream>
using namespace std;
class Student
{
 public:
  int num;
  int score;
  Student(int ,int );//声明构造函数
  void Print();//声明输出信息函数
};
Student::Student(int n,int s)
{
 num=n;
 score=s;
}
void Student::Print(){
 cout<<num<<"\t"<<score<<endl;
}
int main(){
 Student stud(1,100);//实例化一个对象
 Student *p=&stud;//定义一个指向对象的指针,并使用对象stud的地址初始化
 cout<<"*p.num:"<<(*p).num<<endl;//使用指向对象的指针调用数据成员的方式一
 cout<<"p->score:"<<p->score<<endl;//使用指向对象的指针调用数据成员的方式二
 (*p).Print();
 p->Print();
 return 0;
}

指向对象成员的指针
对象有地址,存放对象初始地址的指针变量就是指向对象的指针变量。
对象中的成员也有地址,存放对象成员地址的指针变量就是指向对象成员的指针变量。

1.指向对象数据成员的指针
定义指向对象数据成员的方法和定义指向普通变量的方法相同:
数据类型    *    指针变量名

复制代码 代码如下:

p=&t1.hour;//将对象t1的数据成员hour的地址赋给p,p指向t1.hour
cout<<*p<<endl;//输出t1.hour的值

2.指向对象成员函数的指针
定义指向成员函数的指针和定义指向普通函数的指针的方法是不同的。

定义指向普通函数的指针的方法是这样的:
数据类型名(* 指针变量名)(参数列表);
如:

复制代码 代码如下:

void  (*p)(int n,int m);//p是指向void型函数的指针变量
p=fun;//将fun函数的入口地址赋给指针变量p,p就指向了函数fun
(*p)(a,b);//调用fun函数,其中,a,b是实参

而定义一个指向对象成员函数的指针变量则比较复杂一些。
如果我们直接按照上面的方法定义指针变量,将对象成员函数名赋给指针变量p:

复制代码 代码如下:

void (*p)();        
p=t1.Print();

编译会出现错误
成员函数与普通函数的一个最根本区别:它是类中的一个成员。
编译系统要求上面的复制语句中,指针变量的类型必须与赋值号右侧函数的类型相匹配,要求在一下3个方面要匹配:
1.函数参数的类型和参数个数
2.函数返回值的类型
3.所属的类
前两个是匹配的,而第三点不匹配。
指针变量p与类无关,而Print()却属于Student类。

要定义指向成员函数的指针变量应该采用以下形式:

复制代码 代码如下:

void (Student::*p)();//定义p为指向Student类中公共成员函数的指针变量

数据类型名(类名::*指针变量名)(参数表列);

我们知道,所有的Student类实例化得到的对象都是公用一个成员函数的,所以我们没有必要指定它是指向那个对象的成员函数的指针,我们只需要定义它是指向该类的成员函数就可以了。

使指针变量指向一个公用成员函数的一般形式为:

复制代码 代码如下:

p=&Student::Print;

指针变量名=&类名::成员函数名;

在使用时,仍然需要将指针放到具体的对象中使用,(*p)的作用等价于Print()

复制代码 代码如下:

stud.(*p);//作用与stud.Print()的作用等价

=================一个使用对象指针的例子1.2===========

复制代码 代码如下:

#include<iostream>
using namespace std;
class Student
{
 public:
  int num;
  int score;
  Student(int ,int );
  void Print();
};
Student::Student(int n,int s)
{
 num=n;
 score=s;
}
void Student::Print(){
 cout<<num<<"\t"<<score<<endl;
}
int main(){
 Student stud(1,100);
 cout<<"stud.Print()"<<endl;
        stud.Print();//直接调用对象stud的成员函数Print();
 Student *p_class=&stud;//定义指向对象stud的指针;
 cout<<"p_class->Print()"<<endl;
 p_class->Print();//通过指向对象的指针调用成员函数Print();
 void (Student::*p_fun)();//声明p_fun是指向Student中的函数的指针
 p_fun=&Student::Print;//是p_fun指向Student类公用成员函数Print()
 cout<<"(stud.*p_fun)()"<<endl;
 (stud.*p_fun)();//调用对象stud中的p_fun所指向的成员函数(即:stud.Print)
 return 0;
}


this指针
每个对象中的数据成员都分别占用存储空间,如果对同一个类定义了n个对象,则有n组同样大小的空间一存放n个对象中的数据成员。
单数不同的对象都调用同一段函数代码段。
那么,当不同对象的成员函数引用数据成员时,怎么能保证引用的是所制定的对象的数据成员呢?
实际上,在每一个成员函数中,都包含一个特殊的指针,这个指针的名字是固定的,称为this指针。
它是指向本类对象的指针,它的值是当前被调用的成员函数所在的对象的起始地址。

例如:
Print()函数中

复制代码 代码如下:

 cout<<num<<"\t"<<score<<endl;

实际上是

复制代码 代码如下:

 cout<<this->num<<"\t"<<this->score<<endl;

this指针式隐式使用的,它是作为参数被传递给成员函数。
在程序中的函数:

复制代码 代码如下:

void Student::Print(){
 cout<<num<<"\t"<<score<<endl;
}

C++编译系统会自动处理成:

复制代码 代码如下:

void Student::Print(Student *this){
 cout<<this->num<<"\t"<<this->score<<endl;
}

即在成员函数的形参表列中增加一个this指针。在调用成员函数stud.Print()时,实际上是用以下方式调用的:

复制代码 代码如下:

stud.Print(&stud);

时间: 2024-10-22 05:50:08

C++中的对象指针总结_C 语言的相关文章

解析C++中指向对象的指针使用_C 语言

C++指向对象的常指针将指针变量声明为const型,这样指针值始终保持为其初值,不能改变. 如: Time t1(10,12,15),t2; //定义对象 Time * const ptr1; //const位置在指针变量名前面,规定ptr1的值是常值 ptr1=&t1; //ptr1指向对象t1,此后不能再改变指向 ptr1=&t2; //错误,ptr1不能改变指向 定义指向对象的常指针的一般形式为: 类名 * const 指针变量名; 也可以在定义指针变量时使之初始化,如将上面第2,

详解C++中的对象指针与对象数组_C 语言

C++对象指针 指向对象的指针 在建立对象时,编译系统会为每一个对象分配一定的存储空间,以存放其成员.对象空间的起始地址就是对象的指针.可以定义一个指针变量,用来存放对象的指针. 如果有一个类: class Time { public : int hour; int minute; int sec; void get_time( ); }; void Time::get_time( ) { cout<<hour<<":"<<minute<<

深入解读C++中的指针变量_C 语言

指针变量是一种特殊的变量,它和以前学过的其他类型的变量的不同之处是:用它来指向另一个变量.为了表示指针变量和它所指向的变量之间的联系,在C++中用"*"符号表示指向,例如,i_pointer是一个指针变量,而*i_pointer表示i_pointer所指向的变量. 下面两个语句作用相同: i=3; *i_pointer=3; 定义指针变量 C++规定所有变量在使用前必须先定义,即指定其类型.在编译时按变量类型分配存储空间.对指针变量必须将它定义为指针类型.先看一个具体例子: int i

详解C语言中的常量指针和指针常量_C 语言

概述对于新手来说,指针在c语言里总是一个非常难以理解的概念.在这篇文章中,我们将解释常量指针,指针常量,const pointer to const(ps:楼主以为这可以翻译成指向常量的常量指针)的区别 常量指针让我们先来理解什么是常量指针.常量指针是指指针指向的地址是常量.换句话说,一旦常量指针指向了一个变量,你不能让该常量指针指向其他变量了 常量指针的声明方法如下: <type of pointer> * const <name of pointer> 常量指针声明示例: in

C语言、C++中的union用法总结_C 语言

开始的话 已经好长时间没有更新了,对不起自己,更对不起我亲爱的读者,同时也对不起自己开办的这个博客平台.忙,太忙了,忙于找工作,找一份好工作,纠结于去大城市闯呢,还是回到本省的首府城市.大家都在纠结这个问题,也希望大家和我讨论讨论.别的先不说了,都工作这么长时间了,还回过头来总结union,确实有点过分,要是和大家说我一直从事于C++开发,还不懂union,大家可能还真的不信.我们每天都在总结那些看似高端的东西,什么设计模式(当然我也有总结了).重构(后期我也会说的了)了,却忽略了那些最基础,最

C++交换指针实例_C 语言

本文实例讲述了C++交换指针的方法.分享给大家供大家参考.具体分析如下: 通常情况下,我们只是对普通数据进行交换,交换指针的问题很少涉及,这里总结下,也方便我们以后查阅. 首先看下整型两个数据的交换(这个比较简单,就不多介绍了),核心代码如下: void m_swap(int *a,int *b) { int tmp = *a; *a = *b; *b = tmp; } 指针是内存地址,应该也算是整型变量,交换两个指针和交换两个整型变量类似,下面以两种方式进行. 传统C方式: 可以通过传递指向指

从汇编看c++中的多态详解_C 语言

在c++中,当一个类含有虚函数的时候,类就具有了多态性.构造函数的一项重要功能就是初始化vptr指针,这是保证多态性的关键步骤. 构造函数初始化vptr指针 下面是c++源码: class X { private: int i; public: X(int ii) { i = ii; } virtual void set(int ii) {//虚函数 i = ii; } }; int main() { X x(1); } 下面是对应的main函数汇编码: _main PROC ; 16 : in

在STL中处理对象指针

众所周知,STL的容器类是针对对象来进行存储管理的.虽然没有明确的限制不能在STL的容器类中包含指针,STL也不在乎您存放在容器中的对象还是指针.但仔细考虑STL的初衷,在容器类中使用指针是明显不合时宜的. CKER的意思是您应该尽可能的直接将对象本身而不是将对象的指针放置在STL容器类中.直接在容器中存放指针一个最大的副作用就是可能导致内存泄漏.这个问题在char *类型上有突出的体现. 但某些时候,直接使用对象指针有明显的好处,这些情况大致可以概括为如下的几个方面: 1. 当对象十分庞大时,

C#中Mutex对象用法分析_C#教程

本文实例讲述了C#中Mutex对象用法.分享给大家供大家参考,具体如下: C#语言有很多值得学习的地方,这里我们就来介绍C# Mutex对象,包括介绍控制好多个线程相互之间的联系等方面. 如何控制好多个线程相互之间的联系,不产生冲突和重复,这需要用到互斥对象,即:System.Threading 命名空间中的 Mutex 类. 我们可以把Mutex看作一个出租车,乘客看作线程.乘客首先等车,然后上车,最后下车.当一个乘客在车上时,其他乘客就只有等他下车以后才可以上车.而线程与C# Mutex对象