不用友元,访问类的私有成员变量的方法

C++之友元函数不能访问类的私有成员 无法解决的问题:类中声明,类外定义的成员函数,导致无法访问类中的私有成员函数 去掉using namespace std; 改变#include <iostream>啥的都没用 苍了个天,走过路过的帮个忙? 真的是头大,跟着视频敲代码,人家的代码好好的,就我的出错。本来出现红色波浪线就不舒服,但好在能编译通过,但是,在类中的函数声明和定义分离的时候,编译就不通过,成员函数就无法... 阅读详情
虽然没有现实意义,但对理解C++的对象模型是很有帮助的。

    前几天,在论坛里看到一个帖子,内容是:  
  (原帖见:http://community.youkuaiyun.com/Expert/topic/5014/5014384.xml?temp=.3018152)  

  ========================================  

class a { private: int k; };

    要求不用友元,不在这个类里添加任何代码,去访问成员变量k。  
  能做出的高手,请贴出完整源码,以便大家测试。  
  ========================================  
   
  这道题目本身所要解决的问题并没有多少现实意义,但如果试着去解决它,以及比它更复杂的情况,我认为至少对理解C++的对象模型是很有帮助的。  
   

  开始讨论之前不得不说,这道题做为一个题目存在逻辑上的重大缺陷:“不给类增加一行代码”,我实在想不出如何在验正解题人所提供方案的正确性。只有一个private,难道用解题人所提供的读出方案来验证他自己所提供的写入方案?你用你的方法读出来,然后告诉我那就是你用你的方法写进去的值——那能让人信服吗?所以我决定还是把问题改一改,并稍微具体化如下: 

  要求不用友元,不在这个类里添加任何代码,把成员变量k的值改为100,结果自然是通过公共成员函数get_value来验证。  

  class   Test   {  
  public:  
  int   get_value()   {   return   value;   }  
  private:  
  int   value;  

  };
 “不在类里添加任何代码”,除了  
  #define   private   public  
  我实在想不出其它的“偏门”方法了。那就想想不偏门的吧,论坛里好几位朋友提供了相当于如下代码的方法(为控制篇幅,本文中所有程序段都假设已包含了<iostream>头文件并引入了std名字空间,必要时还有其它头文件):  
  Test   t;  
  *(int*)&t   =   100;  
  cout   <<   t.get_value()   <<   endl;  
  这种方式利用对象内存布局的特点:整个类只有一个整型成员,没有继承或虚拟继承,也没有任何虚函数,那么这个对象的地址也就是它的第一个成员变量的地址,所以只需要把对象地址强转成整型,那么获得的就是那个成员变量的地址,然后对转换后的地址再解引用,修改即可,在VC2003中验证,结果是正确的。  
  但指针的强制转换总给人带来不爽,不大安全的感觉,上面那条最关键的语句相当于:  
  *reinterpret_cast<int*>(&t)   =   100;  

  也就是说,它动用了C++语言中最“强”的指针转换方式(说它最强,是因为没有什么指针之间他不能转换的)。其实我们完全可以做得更“文明”一点,方法是再定义一个联合体,比如: 

  union   TestInt   {  
  Test t;  
  int i;  
  };   
  然后再:   
TestInt   ti;  
  ti.i   =   100;  
  cout   <<   ti.t.get_value()   <<   endl;   
同样达到了目的,但实质上依据的机理跟上面的指针转换是一致的。      
  这个方法没啥大问题,就是有局限性,只能用于修改类的第一个成员,如果在value之前再加一个成员,比如:  

  这种方法就不灵了。  

class   Test   {  
  public:  
  int   get_value()   {   return   value;   }  
  private:  
  char   ch;  
  int   value;  

  };   
  当然,你可以手工算,认为char占一个字节,于是会试图取对象地址再加1得到成员value的地址。但第一,这种方法无法不跨平台跨实现,char及int类型在不同的平台和编译器实现中的长度都可能是不一样的;第二,没有考虑字对齐问题,在内存中,value成员一般不会紧接着排布在ch之后,而是中间间开几个字节,最后将int类型对齐到另一个位置,比如4的倍数的地址上;而更糟糕的是,字对齐不仅跟平台相关,还跟预编译指令,甚至编译选项都会有关。所以,这种手工计算的方式还是放弃了吧。    有朋友提到了使用一种宏求出value成员相对于整个对象起始地址的偏移量,即定义一个宏:  
  #define   OFFSET(TYPE,MEM)   ((int)(char*)&(((TYPE*)0)->MEM))  
  这个宏通过把0地址转换为TYPE指针类型,然后从这个指针上“取”MEM成员,而MEM成员的地址转换后结果就是MEM成员相对于整个对象的偏移量(我们既然是从0地址开始算的,就不用再减去起始地址0)。  
  然后同,我们通过使用这个宏作用于原来的类和目标字段,即:  
  OFFSET(Test,   value)  
  就可以获得value字段在Test类型对象中的偏移量,用对象的首地址加上这个偏移量,就可以得到value变量的地址,从而可以像上面一样解引用,修改。  
  这种方法不仅看起来难受,费解。事实上也根本行不通,因为这个宏所用到的技巧是从Test类型的指针上访问value成员——而valuee是private的!所以连编译都通不过。  
   
  论坛里有位朋友提出了另外一种方法可以巧妙地对付这个复杂一点的类,先做一个辅助类,它跟Test类很像,唯一的不同是它的成员都是public的:  
class   TestTwin   {  
  public:  
  int   get_value()   {   return   value;   }  
  public:  
  char   ch;  
  int   value;  

  };   
  于是,这个TestTwin类跟原来的Test类在内存布局上不会有什么不同,通过指针转换,很容易借助于它来修改Test类对象的value成员:  
  Test   t;  
  TestTwin*   p   =   reinterpret_cast<TestTwin*>(&t);  
  p->value   =   100;  

  cout   <<   t.get_value()   <<   endl;
  如果你不熟悉C++的显式指针转换方式:reinterpret_cast,在这里可以认为它相当于C风格的:  
  TestTwin*   p   =   (TestTwin*)&t;  
  而前述的两条语句也可以合在一起,直接写成:  
  reinterpret_cast<TestTwin*>(&t)->value   =   100;  

  还有,厌恶指针操作的朋友仍可采用前面介绍的联合体方法来运用这个模具类,只是这次定义的联合体是这样:  

  union   TestTestTwin   {  
  Test t;  
  TestTwin tw;  

  };   
  而程序是这样:
  TestTestTwin   ttw;  
  ttw.tw.value   =   100;  

  cout   <<   ttw.t.get_value()   <<   endl;   
  问题都解决了吗?如果类更复杂一些,会不会还有局限性呢?我们再把类改一改:     
  class   Test   {  
  public:  
       int   get_value()   {   return   value;   }  
      ~Test()   {}  
  private:  
       char   ch;  
      int   value;  
  public:  
      int   a;  
      double   b;  
  protected:  
      string   e;  
      private:  
     short   d;  
  };   
  这次不仅成员多了许多,有string类型的成员(须include   <string>),还弄出个虚析构函数来(我们都知道拥有虚函数的类会导致其实例中多一个虚表指针)。但后面会看到,虚函数对我们讨论的问题影响不大,我们加上它只是想证明:只要方法足够好,不怕对象更复杂。  
  那上面的模具办法问题出在哪里呢?为什么不能同样再搞一个类,把那个value改为public的,然后用它来“套住”原来对象中value成员呢?  
  原因是C++语言只保证类中同一个access   section(即从一个访问权限修饰符public/private/protected到另一个修饰符之间的部分)中定义的非静态成员变量会按照声明时的顺序分布的内存中,但并不保证跨越了不同access   section的所有成员变量都在内存中按声明时的顺序存放,某种编译器完全有可能把所有的private块都合成一块,甚至整个给扔到所有protected成员的后边去(虽然VC并没这么做)。  
  换句话说:改掉了一个成员的访问权限,就可能改变了对象的内存布局。于是,改变了的模子也就不再能够套住相应位置上的成员。  
  但办法还是有,只需要将原来的改进一下:  

  在现有的C++对象模型中,为类增加一个非虚成员函数,不会改变对象的内存布局,我们可以利用这一点来写一个TestTwin:

class   TestTwin   {  
  public:  
      int   get_value()   {   return   value;   }  
     void   set_value(int   v)   {   value   =   v;   }  
     ~TestTwin()   {}  
  private:  
       char   ch;  
      int   value;  
  public:  
      int   a;  
      double   b;  
 protected:  
      float   e;  
  private:  
      short   d;  

  };  

  这个模具跟原来的Test类也是只有一点不同:增加了一个公共的,非虚的set_value方法,用来给私有成员value赋值。于是,程序可以这么写:  
Test   t;  
  reinterpret_cast<TestTwin*>(&t)->set_value(100);  

  cout   <<   t.get_value()   <<   endl;   
 验证通过。  
  增加的虚函数纯粹是个障眼物而已,它跟我们采用的方法几乎没有丝毫联系,所以也就丝毫不用担心虚函数对内存分布的影响会影响到这个方法的正确性。但被它一搞,那个使用联合体的方法这一次还真是不管用了,因为有了析构函数的类不能再放进联合体中了——否则当联合体实例的生命周期结束时,析构谁呢?    
   
  想了关天,能想到的只有这么多了。  

  最后,不行不承认,“增加一个非虚成员函数,不会改变对象的内存布局”这句话也无法从C++标准中得到直接支持,只是对于目前大多数编译器来说,这都是没问题的。因为这种“让类的每个实例拥有一份独立的成员变量,而类的所有实例共享一份成员函数”的C++对象模型是C++之父Bjarne   Stroustrup先生本人所提出的,其时间、空间效率都很好地符合了C++语言的设计初衷,不仅现代C++编译器没有不这么做的,就连Java/C#编译器也都这么做。所以,也算是个“相对真理”了。

转自:http://www.cppblog.com/andxie99/archive/2006/10/24/14090.aspx


c++私有成员变量,还可以这样访问 基础不扎实,永远都是坑原来可以这样使用class 的private成员变量 原来可以这样使用class 的private成员变量 private成员变量只能类的内部使用,这句话刚学编程就记住了,可是今天还是遇到了一个颠覆我认知的代码。(如果不是同事提醒,我就可能多绕一圈!) #include <iostream> using namespace std; class testPriv... 阅读详情

相关推荐

Linux-ftrace-双nop机制的实现

linux-ftrace内核追踪-双nop机制的实现原理

qq_43707773的博客 1072

访问类私有成员(非友元函数, 非成员函数)

为什么80%的码农都做不了架构师?>>> ...

weixin_33720452的博客 333

python基础语法与数据结构

本文摘要: Python基础语法包含输入输出、函数、变量、数据类型及运算符等内容。输入函数input()获取键盘输入并以字符串存储,输出函数print()可格式化输出数据。函数通过def定义,可带参数和返回值,提高代码复用性。变量无需声明类型,可动态赋值。数据类型包括数字、字符串、布尔及复合类型,可通过type()查看。运算符包含算术、赋值等类型,其中复合赋值运算符如+=可简化运算。类型转换函数如int()、str()等可实现显式类型转换。这些基础语法构成Python编程的核心要素。

MM602388的博客 436

不用友元如何访问其他类的私有成员

#include <iostream> using namespace std; class test { public: test() { value = 10; } int AAA(); private: int value; }; int test::AAA() { cout << value << endl; return 1; } class Global { public: .

qq_40979987的博客 268

FPGA笔试题知识点汇总(21~40)

FPGA笔试题知识点汇总(21~40)

weixin_52487896的博客 5891

iTunes登录协议全解析:从抓包到加密参数生成(含HTTPDebugger避坑指南)

本文深度解析iTunes登录协议,提供从环境搭建、绕过反调试机制到捕获网络流量的完整实战指南。重点剖析了如何利用HTTPDebugger等工具进行抓包,并详细解读了核心加密参数X-Apple-ActionSignature的生成逻辑,为网络安全研究员和协议分析工程师提供了一份详尽的逆向分析与协议复现教程。

weixin_28314575的博客 871

不使用成员函数或者友元函数访问类的私有成员变量

类的封装就是要将数据成员以及对数据的操作方法kunban

jeasn168的专栏 1809

博图Advanced实战:VB脚本实现HMI画面智能弹出(附完整代码解析)

本文详细介绍了在西门子博图Advanced平台中利用VB脚本实现HMI画面智能弹出的实战方法。通过动态计算坐标、分辨率自适应方案和完整代码解析,帮助工程师解决不同显示环境下的定位难题,提升工业自动化界面的交互体验。

weixin_29041767的博客 345

类中私有的成员如何在类外访问

通过公有的成员函数来访问 友元 通过保存类或者对象的地址进行访问 友元分类: 友元函数:友元函数是将一个全局函数作为一个类的友元,可以在函数内部对所有的成员进行直接操作; 友元类:友元类中的任意一个成员函数可以任意直接操作指定类的成员变量,但是除了成员函数以外其他成员变量无法操作; 友元成员函数:友元成员就是将一个类的成员函数作为另一个类的友元,只有这个成员函数才可以任意操作私有成员 ...

chixiguadelaoye的博客 2897

精密装配机器人系列编程:ABB IRB 120_(20).编程项目设计与实施

在精密装配机器人系列编程中,项目的成功设计与实施涉及多个关键步骤。从项目需求分析到最终调试,每一个环节都需要细致的考虑和专业的技术。选择合适的编程语言、设计良好的程序结构、掌握调试技巧以及解决常见问题,都是确保机器人高效、稳定运行的重要因素。通过不断优化和改进,可以提高生产效率和产品质量,满足不断变化的生产需求。

zhubeibei168的博客 1244

Python 3.13.7 (64-bit)安装弹窗提示:Setup failed:0x80070643 - 安装时发生严重错误...如何解决?

🏆本文收录于 《全栈Bug调优(实战版)》 专栏,该专栏专注于分享我在真实项目开发中遇到的各类疑难Bug及其深层成因,并系统提供高效、可复现的解决思路和实操方案。无论你是刚入行的新手开发者,还是拥有多年项目经验的资深工程师,本专栏都将为你提供一条系统化、高质量的问题排查与优化路径,助力你加速成长,攻克技术壁垒,迈向技术价值最大化与职业发展的更高峰🚀!

**My Coding Family** 2121

c++访问私有成员变量和私有成员函数的常用方法

类的对象不能直接访问类声明的私有成员变量,否则破坏了信息隐藏的目的。 在C++中,为了防止某些数据成员或成员函数从外部被直接访问,可以将它们声明为private,这样编译器会阻止任何来自外部非友元的直接访问。 1.私有成员变量的四种访问方法 (1)通过公共函数为私有成员赋值 #include <iostream> using namespace std; class Test { private: int x, y; public: void setX

是鲤鱼啊 1万+

6、硬件工程师笔试面试知识器件篇——电容(2025版本)

本文系统介绍了电容器的基本原理、类型分类、应用场景及相关设计问题。首先阐述了电容的定义、工作原理及计算公式,详细分析了陶瓷、电解、薄膜、钽等不同类型电容的特性差异。针对高频电路设计,重点讨论了如何评估和优化电容器的寄生效应(ESR/ESL)、频率特性、温度特性等关键参数。文章还提供了PCB布局优化策略,包括缩短走线、多层板设计、去耦网络配置等方法。最后涵盖了电容器寿命计算、稳定性评估及电源电路设计中的纹波电流处理等实用内容,为硬件工程师提供了全面的电容器选型和应用指南。

XU157303764的博客 3875

C++访问类中私有成员变量的方法

原则上,C++类中私有变量不允许在类之外的其他任何地方访问,一般来说功能完善的类都会提供get,set方法来操作类属性值,还有就是就是通过友元访问。但是!但如果没有get、set方法都没有提供,也没有定义友元,比如使用的是第三方提供的.o(或者动态库)来进行开发的,并且实际应用中我们确确实实需要改变其中某个对象的一个私有参数,有没有什么办法呢?还有一种比较文艺青年的方法,我们知道,一个进程有程序段

小熊不去实验室 1万+

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

c++访问类中私有成员变量的几种方法

今天突然遇到这个需求了,就拿出来记录一下。 常用的3种方法 set/get接口 友元类/友元函数 通过指针访问内存地址 1.友元方法 #include<iostream> using namespace std; class A { public: A(){} ~A(){} friend class B; //声明友元类 private: int num = 10; } class B { public: A a; int Sum(){ return a.num + 10

初心不改 1万+

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

c++中类外访问一个类的私有成员

正常来说,类外无法访问类内的private成员,只能通过类内成员访问private成员,在类外,无论是通过类指针还是类对象都无法直接访问类中的private成员 C++类中的私友成员是不能通指针操作的。 #include <iostream> using namespace std; class A { int a;//private public : int b;//publ...

chengchaonan的博客 9146

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

不用友元访问类私有成员 X C++对象模型

   虽然没有现实意义,但对理解C++的对象模型是很有帮助的。    前几天,在论坛里看到一个帖子,内容是:     (原帖见:http://community.youkuaiyun.com/Expert/topic/5014/5014384.xml?temp=.3018152)     ========================================     class   a     {

boluo1982107的专栏 1132

【Python】面向对象 - 封装 ② ( 访问私有成员 | 对象无法访问私有变量 / 方法 | 类内部访问私有成员 )

一、访问私有成员 1、对象无法访问私有变量 2、对象无法访问私有方法 3、类内部访问私有成员

让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 ) 1907

访问类私有成员变量

下面列举了“非类成员”访问“类私有成员变量”的3种方法:     1.通过类公有成员函数set(), get()写、读私有成员;     2.通过类公有成员函数get()获取私有成员的指针或引用,对指针或引用操作;     3.通过友元。     方法1,3都是经常使用的,方法2有点意外(写这篇blog也是因为它);不管怎么说,方法2,3都破坏了类的封装性。 #include

Lemon 2871

iOS访问类的私有成员变量及私有方法

本文主要介绍一下如何访问类的私有成员变量以及类的私有方法,这里以下面这个类来举例: @interface HomeController : UIViewController {     NSString *name2; } @property (nonatomic,copy) NSString *name3; @end

jianghai的博客 1128

C++模板友元魔法【合法的访问私有成员】

神奇!!竟能用模板合法访问私有成员!C++封装瞬间破防!

qq_42370809的博客 758

C++ 类外访问类的私有成员变量

C++ 类外访问类的私有成员变量 之前一直不太清楚对象的成员变量和成员函数在内存中的占用情况,今天想要直接通过一个对象的变量名去访问其内部的成员变量,特地去看了一下对象中的内存布局。 直接说结论: 对于没有继承的情况,对象所占内存的大小和C结构体类似,仅需考虑内存对齐+每个基本成员变量的内存大小就计算出对象所占内存。 对于有继承的情况,如果有虚函数,那么除了基本的成员变量外还会存储一个虚表指针,这个指针的位置可能在这个对象的内存的头部也可能在尾部,这个视编译器而定。派生类对象的内存大小会是父类大小加上自身

man_skill的博客 2780
上一篇: 字符串原地压缩 (思路清晰明了)
下一篇: 齐次坐标 (Homogeneous Coordinate)
sea310
博客等级 码龄17年 2粉丝 1原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值