C++ 访问main函数内部的私有数据

内部main.cpp

class vivek
{
    int i;
    float d;
public:
    vivek()
    {
        i = 4;
        d = 4.44;
    }
    ~vivek()
    {
        cout << "destructor" << i;
    }
    int get()
    {
        return i;
    }
};

int main()
{
    vivek *viku = new vivek;
    vivek *p;

    p = viku;
    cout << (*(int*) (p));
    getchar();

    return 0;
}

class vivek
{
int i；
浮动d；
公众：
维韦克（）
{
i=4；
d=4.44；
}
~vivek（）
{
课堂上的cout
vivek

public:
  float getD() {
    return this -> d;
  }

并在代码中调用它，如下所示：

std::cout << (p -> getD()) << std::endl;

std:：cout getD（））如果您想/需要访问它们，请将它们设置为
public
。这就是
public
的要点，它意味着类的用户可以查看和更改
public
的内容

有人可能会告诉你这“破坏了封装”。但是，如果你只需要类来保存一些值，而不需要做任何花哨的事情，那么将数据成员公开并不是一个问题。
虽然它非常粗糙，但这是可能的，因为
vivek
是一个标准的布局结构。这意味着你可以做到：

#include <iostream>

// copied from original
class vivek {
  int i;
  float d;
public:
  vivek() {i = 4; d = 4.44; }
  ~vivek() { cout<<"destructor"<<i; }
  int get() { return i; }
};

struct vivek_sneaky_accessor {
  int i;
  float d;
};

int main() {
  vivek v;
  vivek_sneaky_accessor *acc = reinterpret_cast<vivek_sneaky_accessor*>(&v);
  std::cout << acc->d;
  return 0;
}

#包括
//抄袭
vivek类{
int i；
浮动d；
公众：
vivek（）{i=4；d=4.44；}
~vivek（）{cout我会冒被否决的风险，因为我认为你这么做是为了理解指针

也许，你所期待的是这样的：

int*x=reinterpret_cast（p）；

x++；

cout冒着被语言律师否决的风险，这里有一点黑客的建议给你，希望它可能会很有趣。私人成员不应该从类外和类的朋友处访问。但是，如果你绝对必须访问类的那些成员字段，像这样的黑客可以工作：

#include <iostream>

class vivek {
    int   i;
    float d;

  public:
    vivek() : i(4), d(4.44) {}
    ~vivek() {}
};

int main()
{
    vivek viku;
    struct badhack {
        int   i;
        float d;
    } *h = (sizeof(badhack) == sizeof viku ? (badhack*)&viku
            : ((badhack*)((char*)&viku + sizeof(void*))));
    std::cout << "i=" << h->i << ", d=" << h->d << std::endl;
}

然而，请注意，上述内容很可能不适用于成员函数。现在的编译器是智能的，并且根据其访问级别对函数名进行不同的修改

请不要使用这样的技巧，除非是为了拯救某人的生命，并且你愿意牺牲你的生命作为回报。
虽然可以将对象视为字节序列并直接处理这些字节，但这是一个非常糟糕的主意。拥有类和对象的全部目的是为了拯救你的tro不必考虑数据在内存中的实际布局。
你不能。（你甚至不能做你现在正在做的事情；你很不幸它起了作用）你为什么要这么做？你不能。这就是重点。这不关
main
的事。而且，你有一个巨大的内存泄漏。@R.MartinhoFernandes实际上，他们可以做他们现在正在做的事情。
vivek
是一个标准的布局结构，因此，根据[class.mem]第20点，“指向标准布局结构对象的指针（使用reinterpret_转换进行适当转换）指向其初始成员…反之亦然。"就在我的一次采访中，他们让我得到d的值。我知道在我们的编程世界中，我们从来没有使用过这个。有没有办法像访问变量p一样访问变量d？@Angew哦，你是对的。我认为这只是为了简单的复制。@Angrew:非常感谢..这就是我想要的东西。你把对象的地址记在一个int指针。向其添加1，使其递增sizeof（int）。现在，您的内存位置的地址就在它旁边。您将它转换为浮点指针和打印值。您将得到结果。但是，请在阅读文章后尝试运行它：）+1一个简短的答案。当类是动态多态继承树的一部分时，此行为会发生变化吗？请尝试使用双精度而不是float并告诉我它是否仍然有效。定义顺序的事实并不意味着定义了位置。@daramarak是的，当这种情况发生时，这将停止工作。它也将停止工作，进行不太彻底的更改，例如使第二个成员的对齐方式比int更严格，就像大多数实现中的double。@R.MartinhoFeRANDANES。是的，它仍然适用于我的机器。但是，我必须强调的是，我从来没有说过这是应该做的事情，或者会一直工作。问题是，仅仅拥有一些值的类会随着时间的推移而增长。在你知道它之前，你有一个复杂逻辑的大类，它的数据成员在很多PAR中被直接访问。这是一个很好的经验法则。对我来说，这听起来像是在开始时过度设计，而在成长过程中又缺乏设计。一个更好的经验法则是实际拥有类不变量。如果公共成员可以拥有这些不变量，那么在需要非公共成员的未来是一个突破性的变化。在编译时破坏代码的突破性变化比在静默编译时更好。
#include <iostream>

#define class struct
#define private public

class vivek {
    int   i;
    float d;

  public:
    vivek() : i(4), d(4.44) {}
    ~vivek() {}
};

int main()
{
    vivek viku;
    std::cout << "i=" << viku.i << ", d=" << viku.d << std::endl;

    return 0;
}