标签: pointers

在指针上执行取消引用操作有多贵？

我可以想象内存传输在某种程度上与对象大小成比例,但我想知道解除引用操作部分有多昂贵.

我有一个std::vector与n元素.现在我需要将指针传递n-1给具有函数最后元素的向量.

例如,我的vector<int> foo包含(5,2,6,87,251).一个函数需要vector<int>*,我想传递一个指针(2,6,87,251).

我可以(安全地)获取迭代器++foo.begin(),将其转换为指针并将其传递给函数吗？还是用&foo[1]？

更新:人们建议我改变我的函数来获取迭代器而不是指针.在我的情况下,这似乎是不可能的,因为我提到的find功能是...的功能unordered_set<std::vector*>.那么在这种情况下,是将n-1元素复制foo到一个新的向量中并find使用指向该唯一选项的指针进行调用？非常低效!这就像画家Shlemiel,特别是因为我必须查询许多子集:最后一个n-1,然后n-2等等元素,看看它们是否在unordered_set.

我有一个如下结构,带有一个指向名为"length"的函数的指针,该函数将返回chars成员的长度.

typedef struct pstring_t {
    char * chars;
    int (* length)();
} PString;

我有一个函数来返回从指针到PString的字符长度:

int length(PString * self) {
    return strlen(self->chars);
}

我有一个函数initializeString(),它返回一个指向PString的指针:

PString * initializeString() {
    PString *str;
    str->length = &length;
    return str;
}

很明显,我在这里做了一些非常错误的指针,因为该str->length = &length行在我的调试器中会产生一个EXC_BAD_ACCESS信号,就像返回strlen(self-> chars)一样.有没有人对这个问题有任何见解？

我特别希望能够让initializeString()函数返回指向PString的指针,并使用指向PString的指针作为输入的长度函数.这只是在C中实现基本的面向对象系统的一个实验,但我没有很多经验处理指针的经验.感谢你给与我的帮助.

我正在寻找创建两个类,每个类包含另一个类类型的对象.我怎样才能做到这一点？如果我不能这样做,是否有一个解决方法,比如每个类包含一个指向另一个类类型的指针？谢谢!

这就是我所拥有的:

文件:bar.h

#ifndef BAR_H
#define BAR_H
#include "foo.h"
class bar {
public:
  foo getFoo();
protected:
  foo f;
};
#endif

文件:foo.h

#ifndef FOO_H
#define FOO_H
#include "bar.h"
class foo {
public:
  bar getBar();
protected:
  bar b;
};
#endif

文件:main.cpp

#include "foo.h"
#include "bar.h"

int
main (int argc, char **argv)
{
  foo myFoo;
  bar myBar;
}

$ g ++ main.cpp

In file included from foo.h:3,
                 from main.cpp:1:
bar.h:6: error: ‘foo’ does not name a …

在求职面试中,我被问到"在C++中如何更快地访问变量,尽管是正常的变量标识符或通过指针".我必须说我对这个问题没有很好的技术答案,所以我做了一个疯狂的猜测.

我说访问时间可能与普通变量相同/标识符是指向存储值的内存地址的指针,就像指针一样.换句话说,就速度而言,它们都具有相同的性能,并且指针只是不同,因为我们可以指定我们希望它们指向的内存地址.

面试官似乎对我的回答并不十分信服/满意(虽然他没有说什么,只是继续问别的东西),因此我来问问他们,我的回答是准确的,如果不是为什么(来自理论和技术POV).

下面的两个代码示例都在链接列表的顶部添加了一个节点.但是,第一个代码示例使用双指针,而第二个代码示例使用单个指针

代码示例1:

struct node* push(struct node **head, int data)
{
        struct node* newnode = malloc(sizeof(struct node));
        newnode->data = data;
        newnode->next = *head;
        return newnode;
}

push(&head,1);

代码示例2:

struct node* push(struct node *head, int data)
{
        struct node* newnode = malloc(sizeof(struct node));
        newnode->data = data;
        newnode->next = head;
        return newnode;
}

push(head,1)

两种策略都有效.但是,许多使用链表的程序使用双指针来添加新节点.我知道双指针是什么.但是如果单个指针足以添加新节点,为什么很多实现都依赖于双指针？

有没有一个指针不起作用的情况所以我们需要去一个双指针？

鉴于我的变量是一个指针,如果我将它分配给"auto"类型的变量,我是否指定"*"？

std::vector<MyClass> *getVector(); //returns populated vector
//...

std::vector<MyClass> *myvector = getVector();  //assume has n items in it
auto newvar1 = myvector;

// vs:
auto *newvar2 = myvector;

//goal is to behave like this assignment:
std::vector<MyClass> *newvar3 = getVector();

我对autoc ++ 11的工作方式有点困惑(这是c ++ 11的新功能,对吧？)

更新:我修改了上面的内容,以更好地阐明我的向量是如何在函数中填充的,我只是尝试将返回的指针赋给变量.对困惑感到抱歉

在调用以下代码时,尝试将"self"传递给swift中的C函数:

var callbackStruct : AURenderCallbackStruct = 
    AURenderCallbackStruct.init(
      inputProc: recordingCallback,
      inputProcRefCon: UnsafeMutablePointer<Void>
    )

在这里将"self"转换为UnsafeMutablePointer类型的理想方法是什么？

我最近一直在学习 C++ 并意识到 C++ 中的字符串文字必须是常量，而在 C 中，它们不是。这是一个例子。以下代码在 C 中有效，但在 C++ 中无效：

char* str = "Hello World";

为了在 C++ 中做同样的事情，必须使用以下语句：

const char* str = "Hello World";

有人可以解释为什么吗？

你应该在C#代码中使用指针吗？有什么好处？它是由The Man(微软)推荐的吗？