标签: pointers

我有一个包含C函数的DLL,其原型如下:

int c_read_block(uint32 addr, uint32 *buf, uint32 num);

我想用ctypes从Python中调用它.该函数需要一个指向一块内存的指针,它将写入结果.我不知道如何构造和传递这么一块内存.ctypes文档没有多大帮助.

构造一个数组并将其传递给"byref",如下所示:

    cresult = (c_ulong * num)()
    err = self.c_read_block(addr, byref(cresult), num)

给出此错误消息:

ArgumentError: argument 3: <type 'exceptions.TypeError'>: expected LP_c_ulong instance instead of pointer to c_ulong_Array_2

我想这是因为Python ulong数组与ac uint32数组完全不同.我应该用吗create_char_string？如果是这样,我如何说服Python将该缓冲区"转换"为LP_c_ulong？

在C++中是否可以在特定的内存位置创建新对象？我有一个共享内存块,我想在其中创建一个对象.这可能吗？

我和C一起工作,我有点生疏了.我知道它*有三个用途:

1. 声明一个指针.
2. 取消引用指针.
3. 乘法

但是,**在变量声明之前有两个星号()时它意味着什么:

char **aPointer = ...

谢谢,

斯科特

在C++ IS的C.1.3(2003.它也在C++ 11 IS中),该标准指出了ISO C和C++之间的差异; 即,为

char arr[100];

sizeof(0, arr)以C语言返回sizeof(char*),但100在C++中.

我找不到sizeof两个参数的文档.明显的后备是逗号运算符,但我不这么认为:sizeof(arr)在C中100; sizeof(0, arr)是sizeof(char*).两个sizeof(0, arr)和sizeof(arr)是100在C++中.

在这种情况下,我可能会忽略IS的重点.有人可以帮忙吗？这类似于09年讨论的问题,但没有人提到IS,我认为没有给出正确的答案.

编辑:实际上,IS正在谈论逗号运算符.因此,出于某种原因,在C中(0, arr)返回a char*,但char[100]在C++中返回a .为什么？

我知道C中的数组只是指向顺序存储数据的指针.但是,差异意味着符号[]和*的区别.我的意思是在所有可能的使用环境中 例如:

char c[] = "test";

如果在函数体中提供此指令,它将在堆栈上分配字符串

char* c = "test";

将指向数据(只读)段.

您是否可以在所有使用情境中列出这两种表示法之间的所有差异,以形成清晰的一般视图.

我知道对于单维数组 x=a[i]来说相当于x=*(a+i),但是如何使用指针访问二维数组的元素呢？

我已经使用了几年的指针,但我最近才决定转换到C++ 11的智能指针(即唯一,共享和弱).我对它们做了很多研究,这些是我得出的结论:

1. 独特的指针很棒.他们管理自己的内存,并且像原始指针一样轻量级.首选尽可能多地使用unique_ptr而不是原始指针.
2. 共享指针很复杂.由于引用计数,它们具有显着的开销.通过const引用传递它们或后悔你的方式的错误.它们不是邪恶的,但应该谨慎使用.
3. 共享指针应该拥有对象; 在不需要所有权时使用弱指针.锁定weak_ptr具有与shared_ptr复制构造函数相同的开销.
4. 继续忽略auto_ptr的存在,现在无论如何都不推荐使用它.

因此,考虑到这些原则,我开始修改我的代码库以利用我们新的闪亮智能指针,完全打算清除尽可能多的原始指针.然而,我对如何最好地利用C++ 11智能指针感到困惑.

例如,让我们假设我们正在设计一个简单的游戏.我们认为将虚构的Texture数据类型加载到TextureManager类中是最佳的.这些纹理很复杂,因此按值传递它们是不可行的.此外,让我们假设游戏对象需要特定的纹理,具体取决于它们的对象类型(即汽车,船等).

之前,我会将纹理加载到矢量(或其他容器,如unordered_map)中,并在每个相应的游戏对象中存储指向这些纹理的指针,以便在需要渲染时可以引用它们.让我们假设纹理保证比指针寿命更长.

那么,我的问题是如何在这种情况下最好地利用智能指针.我看到几个选项:

1. 将纹理直接存储在容器中,然后在每个游戏对象中构造unique_ptr.

   class TextureManager {
     public:
       const Texture& texture(const std::string& key) const
           { return textures_.at(key); }
     private:
       std::unordered_map<std::string, Texture> textures_;
   };
   class GameObject {
     public:
       void set_texture(const Texture& texture)
           { texture_ = std::unique_ptr<Texture>(new Texture(texture)); }
     private:
       std::unique_ptr<Texture> texture_;
   };
   

   Run Code Online (Sandbox Code Playgroud)

   然而,我对此的理解是,新的纹理将从传递的引用中复制构造,然后由unique_ptr拥有.这让我觉得非常不受欢迎,因为我会使用与使用它的游戏对象一样多的纹理副本 - 击败指针点(没有双关语意).

2. 不直接存储纹理,而是存储容器中的共享指针.使用make_shared初始化共享指针.构造游戏对象中的弱指针.

   class TextureManager {
     public:
       const std::shared_ptr<Texture>& texture(const std::string& key) const
           { return textures_.at(key); }
     private:
       std::unordered_map<std::string, std::shared_ptr<Texture>> textures_;
   };
   class GameObject {
     public:
       void set_texture(const std::shared_ptr<Texture>& …

   Run Code Online (Sandbox Code Playgroud)

这里引用了cppreference的实现说明部分std::shared_ptr,其中提到有两个不同的指针(如粗体所示):可以返回的指针get(),以及控制块中保存实际数据的指针.

在典型的实现中,std::shared_ptr只保留两个指针:

1. 存储的指针(返回一个get())
2. 指向控制块的指针

控制块是一个动态分配的对象,它包含:

1. 指向托管对象的指针或托管对象本身
2. 删除(类型擦除)
3. 分配器(类型擦除)
4. 数量shared_ptrs是自己的管理对象
5. 的数目weak_ptrs引用该管理对象

shared_ptr直接保持的指针是由返回get()的指针,而控制块保持的指针或对象是当共享所有者的数量达到零时将被删除的指针或对象.这些指针不一定相等.

我的问题是,为什么托管对象需要两个不同的指针(两个粗体)(除了指向控制块的指针)？那个回来的人get()不够吗？为什么这些指针不一定相等？

我是C的新手,具有良好的java背景,我正在尝试理解指针和数组.

我知道下标operator[]是数组定义的一部分,所以:

int numbers[] = {1,3,4,5};

会创建一个整数数组,它将在内存中表示为16个字节,4个4个字节:

numbers[0] = 1, address 0061FF1C
numbers[1] = 3, address 0061FF20
numbers[2] = 4, address 0061FF24
numbers[3] = 5, address 0061FF28

但是,当涉及指针时,我的知识开始崩溃,所以如果我要创建一个指向数组数字的指针,我将执行以下操作:

int *pNumbers = &numbers[0];

看起来像这样:

而且我猜它的大小是4字节？

然而,**我读作"指针指针"对我来说没有意义,为什么有人想要指针指针,当然如果a-> b-> c然后a-> c就足够了？我知道我错过了一些东西,它必须与数组有关,argv可以是类型char[ ]或char **下面看到的:

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

所以:

• 这是什么(**)？
• 它有什么用途？
• 它在记忆中如何表现？

关于和运营商的C标准第6.5.9节规定如下:==!=

2下列之一应持有:

• 两个操作数都有算术类型;
• 两个操作数都是指向兼容类型的限定或非限定版本的指针;
• 一个操作数是指向对象类型的指针,另一个是指向合格或非限定版本的void的指针; 要么
• 一个操作数是一个指针,另一个是空指针常量.

...

6 两个指针比较相等,当且仅当两个都是空指针时,两者都是指向同一对象的指针(包括指向对象的指针和在其开头的子对象)或函数,两者都是指向同一对象的最后一个元素的指针数组对象,或者一个是指向一个数组对象末尾的指针,另一个是指向不同数组对象的开头的指针,该数组对象恰好跟随地址空间中的第一个数组对象.¹⁰⁹⁾

7出于这些运算符的目的,指向不是数组元素的对象的指针与指向长度为1的数组的第一个元素的指针的行为相同,其中对象的类型为其元素类型.

脚注109:

109)两个对象在内存中可能相邻,因为它们是较大数组的相邻元素或结构的相邻成员,它们之间没有填充,或者因为实现选择放置它们,即使它们是不相关的.如果先前的无效指针操作(例如数组边界外的访问)产生了未定义的行为,则后续比较也会产生未定义的行为.

这似乎表明您可以执行以下操作:

int a;
int b;
printf("a precedes b: %d\n", (&a + 1) == &b);
printf("b precedes a: %d\n", (&b + 1) == &a);

这应该是合法的,因为我们使用地址一个元素超过数组的末尾(在这种情况下是一个被视为大小为1的数组的单个对象),而不解除引用它.更重要的是,1如果一个变量在内存中紧跟另一个变量,则需要输出这两个语句中的一个.

但是,测试似乎没有把它弄平.鉴于以下测试计划:

#include <stdio.h>

struct s {
    int a;
    int b;
};

int main()
{
    int a;
    int b;
    int *x = &a;
    int *y = &b;

    printf("sizeof(int)=%zu\n", …