标签: memory-address

我知道下面写的代码是非法的

void doSomething(std::string *s){}
int main()
{
     doSomething(&std::string("Hello World"));
     return 0;
}

原因是我们不允许获取临时对象的地址.但我的问题是为什么？

让我们考虑以下代码

class empty{};
int main()
{
      empty x = empty(); //most compilers would elide the temporary
      return 0;
}

公认的答案在这里提到

"通常编译器会将临时和副本构造为两个对象,它们位于内存的完全相同的位置,并避免复制."

根据声明,可以得出结论,临时存在于某个内存位置(因此可能已经采用了它),编译器决定通过在临时存在的同一位置创建就地对象来消除临时对象. .

这是否与临时地址不能采取的事实相矛盾？

我还想知道如何实现返回值优化.有人可以提供与RVO实施相关的链接或文章吗？

我知道我应该设置mem=MEMORY_LIMIT.但是我不知道去哪里,在运行时或在引导期间,为了设置操作系统控制的总物理内存的限制.

我正在运行I/O基准测试,我想限制可用的整体物理内存量.

为什么不能取位域的地址？

如何制作指向位字段的指针？

这是代码......

struct bitfield {
    unsigned int a: 1;
    unsigned int b: 1;
    unsigned int c: 1;
    unsigned int d: 1;
};

int main(void)
{
    struct bitfield pipe = {
        .a = 1, .b = 0,
        .c = 0, .d = 0
    };
    printf("%d %d %d %d\n", pipe.a,
            pipe.b, pipe.c, pipe.d);
    printf("%p\n", &pipe.a); /* OPPS HERE */
    // error: cannot take address of bit-field ...
    return 0;
}

如何读取带有模块基址的内存？例如,如何读取此内存:"winCap64.dll"+ 0x123456 +偏移量.

我已经添加了一些示例代码,说明了我在研究后可以生成的内容,但我仍然无法在C#中读取任何内容.但是地址非常好,因为当我在Cheat Engine上添加它们时它们会返回正确的值.

编辑:添加了samle代码

    [DllImport("kernel32.dll")]
    static extern IntPtr OpenProcess(UInt32 dwDesiredAccess, Boolean bInheritHandle, UInt32 dwProcessId);
    [DllImport("kernel32.dll")]
    static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress,
    byte[] lpBuffer, UIntPtr nSize, uint lpNumberOfBytesWritten);

    static IntPtr Handle;

    static void Main(string[] args)
    {
        Process[] Processes = Process.GetProcessesByName("process");
        Process nProcess = Processes[0];
        Handle = OpenProcess(0x10, false, (uint)nProcess.Id);
        IntPtr pointer = IntPtr.Add(nProcess.Modules[125].BaseAddress, 0x020C5150);
        int curhp = ReadOffset(pointer, 0x4D8);
        int curhp2 = ReadOffset((IntPtr)curhp, 0x0);
        int curhp3 = ReadOffset((IntPtr)curhp2, 0x1c0);
        Console.WriteLine(curhp3.ToString());
        Console.ReadKey();
    }

    public static int ReadOffset(IntPtr pointer, uint …

这个赋值要求我们使用malloc()(命名var1和var2)分配两个int类型变量,打印每个变量的地址(堆栈上指针的地址和堆上的地址),然后free()用来解除分配var1,再次打印地址,然后在堆中分配另一个空间var1并第三次打印地址.我相信教师试图告诉我们堆地址var1应该改变,但它始终保持不变......除非我free(var1)从代码中删除.教练做了类似的演示,但没有free()用来解除分配任何变量,所以我们从来没有看到它应该如何工作.

这是我的代码:

#include <stdio.h>
#include <stdlib.h>

void main()
{

int *var1 = (int*)malloc(sizeof(int)); 
*var1 = 1000;                   
int *var2 = (int*)malloc(sizeof(int)); 
*var2 = 2000;

printf("Addresses of var1\n");
printf("Pointer on stack: %p / Heap: %p\n\n", &var1, var1); 
printf("Addresses of var2\n");
printf("Pointer on stack: %p / Heap: %p\n\n", &var2, var2);

free(var1);

printf("AFTER DEALLOCATING var1 FROM THE HEAP\n");
printf("Addresses of var1\n");
printf("Pointer on stack: %p / …

可以说我有一个普通的页面表:

页表(页面大小= 4k)

      Page #:  0  1  2  3  4  5  6  7  8  9  10  11  12  13  14  15          
Page Frame #:  3  x  1  x  0  x  2  x  5  x   7   4   6   x   x   x

如何将51996之类的任意逻辑地址转换为物理内存地址？

如果我使用log base 2(4096),我得到12.我认为这是我想用于地址偏移的位数.

我只是不确定.51996/4096 = 12.69.那么这是否意味着它位于第12页,具有一定的偏移量？

然后我如何将其转换为"51996"的物理地址？

我正在读一本关于二元搜索树的书,有些奇怪的东西出现了.

class BST
{
public:
   void insert(const Comparable & item)

private:
   BinaryNode *root;
   struct BinaryNode
   {
       Comparable element;
       BinaryNode *left;
       BinaryNode *right;
       BinaryNode(const Comparable & theElement, BinaryNode *lt, BinaryNode *rt) : 
          element(theElement), left(lt), right(rt) {}
   }
   void insert(const Comparable & item, BinaryNode * & t) const;
};

该private insert函数是函数的辅助函数public insert,private insert函数查找使用递归插入的正确位置.

我不明白的部分是BinaryNode * & t在参数中.这是什么意思？指针的地址t？

字典键需要Hashable符合:

class Test {}
var dictionary = [Test: String]() // Type 'Test' dies not conform to protocol 'Hashable'

class Test: NSObject {}
var dictionary = [Test: String]() // Works

如何获取纯Swift类实例的地址hashValue？

可能重复:
为什么不显示char数据的地址？

这是代码和输出:

int main(int argc, char** argv) {

    bool a;
    bool b;

    cout<<"Address of a:"<<&a<<endl;
    cout<<"Address of b:"<<&b<<endl;

    int c;
    int d;

    cout<<"Address of c:"<<&c<<endl;
    cout<<"Address of d:"<<&d<<endl;

    char e;    
    cout<<"Address of e:"<<&e<<endl;

    return 0;
}

输出:

地址a:0x28ac67

地址b:0x28ac66

地址c:0x28ac60

地址d:0x28ac5c

地址:

我的问题是:char的内存地址在哪里？为什么不打印？

谢谢.

在"低级编程:英特尔®64架构上的C,汇编和程序执行"一书中,我读到:

每个虚拟64位地址(例如,我们在程序中使用的地址)由几个字段组成.地址本身实际上只有48位宽; 它被符号扩展为64位规范地址.它的特点是它的17个左位是相等的.如果不满足条件,则在使用时立即拒绝该地址.然后借助特殊表将48位虚拟地址转换为52位物理地址.

为什么虚拟地址和物理地址之间的差异为4位？