标签: pointers

这是真的,Asterisk总是意味着"嘿,这是一个指针!" 指针总是有一个记忆地址？

(是的我知道a*用于数学运算的例外)

例如:

NSString* myString;

要么

SomeClass* thatClass;

要么

(*somePointerToAStruct).myStructComponent = 5;

我觉得在定义一个指向类的指针的变量时,我需要了解更多关于Asterirsk(*)的信息.

因为有时我已经在参数声明中说过Parameter变量是一个指针,但我仍然需要在变量前面使用Asterisk来访问该值.最近发生在我希望以类似[myObj myMethod:&myStruct]的方式将结构的指针传递给方法之后,即使我的方法声明已经说过有参数,我也无法从该结构访问组件值( DemoStruct*)myVar确实应该被称为指向该demostruct的指针,我仍然总是说:"人,编译器.听!它IIISSS指针:"并写:(*myVar).myStructComponentX = 5;

我真的真的不明白为什么我要说两次.只有在这种情况下.

当我在NSString*myString的上下文中使用Asterisk时,我可以只访问myString但是我不喜欢每次都告诉编译器它是指针.即喜欢使用*myString = @"yep".

这对我来说毫无意义.

我遇到了一个情况,我有一个非常大的文件,我需要从中读取二进制数据.

因此,我意识到.NET中的默认BinaryReader实现非常慢.用.NET Reflector查看它后,我发现了这个:

public virtual int ReadInt32()
{
    if (this.m_isMemoryStream)
    {
        MemoryStream stream = this.m_stream as MemoryStream;
        return stream.InternalReadInt32();
    }
    this.FillBuffer(4);
    return (((this.m_buffer[0] | (this.m_buffer[1] << 8)) | (this.m_buffer[2] << 0x10)) | (this.m_buffer[3] << 0x18));
}

这让我觉得非常低效,想到自32位CPU发明以来计算机是如何设计用于32位值的.

所以我使用这样的代码创建了我自己的(不安全的)FastBinaryReader类:

public unsafe class FastBinaryReader :IDisposable
{
    private static byte[] buffer = new byte[50];
    //private Stream baseStream;

    public Stream BaseStream { get; private set; }
    public FastBinaryReader(Stream input)
    {
        BaseStream = input;
    }


    public int ReadInt32()
    {
        BaseStream.Read(buffer, 0, 4);

        fixed …

将指针转换为int并稍后再返回指针是否安全？

如果我们知道指针是否为32位长且int是32位长怎么样？

long* juggle(long* p) {
    static_assert(sizeof(long*) == sizeof(int));
    int v = reinterpret_cast<int>(p); // or if sizeof(*)==8 choose long here
    do_some_math(v); // prevent compiler from optimizing
    return reinterpret_cast<long*>(v);
}

int main() {
    long* stuff = new long(42);
    long* ffuts = juggle(stuff); 
    std::cout << "Is this always 42? " << *ffuts << std::endl;
}

这是否包含在标准中？

有没有办法在C中对齐指针？假设我正在将数据写入数组堆栈(因此指针向下移动)并且我希望我写入的下一个数据是4对齐的,因此数据写入的内存位置是4的倍数,我该怎么做那？

我有

 uint8_t ary[1024];
 ary = ary+1024;
 ary -= /* ... */

现在假设ary在位置点0x05.我希望它指向0x04.现在我可以做到

ary -= (ary % 4);

但是C不允许模数指针.有没有与架构无关的解决方案？

我知道有很多关于指针的问题,特别是现在的Objective-C.但我正在寻找一些更高级别的答案来帮助我理解Objective-C中的范例.

我听说有人说在Objective-C中使用指针是一个问题或经验,即有些类要求你使用指针,有些则不然.这是真的？这是在Objective-C中使用指针的程度.

基本上,除了想要将引用变量显式传递给方法之外,Objective-C中指针的规则是什么？

昨天我参加了一家知名欧洲公司的CTO的演讲,直到最近他才知道java有指针.在面对他时,他说他绝对肯定java中存在指针/不安全代码.

我正在编写一个glfw应用程序,我将函数调用函数包装到一个简单的类中.我在设置密钥回调时遇到问题.我的课程定义为:

class GAME 
{
private:
    bool running;
public:
    GAME();
    int execute();
    void events(int, int);
    int loop();
    int render();
};

执行功能是:

int GAME::execute() 
    {
        glfwOpenWindow(640, 320, 8, 8, 8, 8, 0, 0, GLFW_WINDOW);
        glfwSetWindowTitle("Viraj");
        glfwSetKeyCallback(events);
        running = true;
        while(glfwGetWindowParam(GLFW_OPENED))
        {
            glfwPollEvents();
            loop();
            render();
        }
        return 0;
    }

在Visual Studio 2010上编译以下代码,给出错误:

error C3867: 'GAME::events': function call missing argument list; use '&GAME::events' to create a pointer to member

使用&GAME :: events提供:

error C2664: 'glfwSetKeyCallback' : cannot convert parameter 1 from 'void (__thiscall GAME::* …

12.4.2的C++标准规定了这一点

[...]不得采用析构函数的地址.[...]

但是,编译器可以在没有任何抱怨的情况下获取类析构函数周围的包装器的地址,如下所示:

struct Test {
    ~Test(){};

    void destructor(){
        this->~Test();
    }
};

void (Test::*d)() = &Test::destructor;

那么禁止直接获取析构函数地址的理由是什么呢？

以下代码(跨子对象边界执行指针运算)是否具有明确定义的行为,适用T于它编译的类型(在C++ 11中,不一定必须是POD)或其任何子集？

#include <cassert>
#include <cstddef>

template<typename T>
struct Base
{
    // ensure alignment
    union
    {
        T initial;
        char begin;
    };
};

template<typename T, size_t N>
struct Derived : public Base<T>
{
    T rest[N - 1];
    char end;
};

int main()
{
    Derived<float, 10> d;
    assert(&d.rest[9] - &d.initial == 10);
    assert(&d.end - &d.begin == sizeof(float) * 10);
    return 0;
}

LLVM在内部向量类型的实现中使用上述技术的变体,该内部向量类型被优化以最初将堆栈用于小型阵列,但是在初始容量上切换到堆分配的缓冲区.(之所以做这种方式是不是从这个例子清楚,但显然是要减少模板代码膨胀,这是更清楚,如果你去翻代码.)

注意:在任何人抱怨之前,这并不是他们正在做的事情,可能是他们的方法比我在这里给出的标准更符合标准,但我想询问一般情况.

显然,它在实践中有效,但我很好奇,如果标准中的任何内容保证是这样的话.考虑到N3242/expr.add,我倾向于拒绝.

当减去指向同一数组对象的元素的两个指针时,结果是两个数组元素的下标的差异...此外,如果表达式P指向数组对象的元素或者指向最后一个元素的元素对于数组对象,并且表达式Q指向同一数组对象的最后一个元素,表达式((Q)+1) - (P)具有与((Q) - (P))+ 1相同的值,并且as …

我遇到了一个有竞争力的问题,询问以下内容的输出:

#include <stdio.h>
int main()
{
    int a[] = {0,1,2,3,4};
    int i, *ptr;
    for(ptr = a+4, i=0; i <=4; i++)
    printf("%d", ptr[-i]);
    return 0;
}

我确实读过这个话题:C中是否允许使用负数组索引？然而,我不清楚-ve符号如何以相反的顺序生成数组,即.4, 3, 2, 1, 0.