指针到底存储什么？ (C++)

发布于 2024-07-23 23:08:45 字数 194 浏览 2 评论 0原文

我知道指针存储它们指向的值的地址，但是如果将指针的值直接显示到屏幕上，您会得到一个十六进制数。如果该数字正是指针存储的数字，则表示

pA = pB; //both are pointers

您正在复制地址。那么，在处理像 int 和 bool 这样非常小的项目时，使用指针会不会产生更大的开销？

原文

I know that pointers store the address of the value that they point to, but if you display the value of a pointer directly to the screen, you get a hexadecimal number. If the number is exactly what the pointer stores, then when saying

pA = pB; //both are pointers

you're copying the address. Then wouldn't there be a bigger overhead to using pointers when working with very small items like ints and bools?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

抽个烟儿 2024-07-30 23:08:47

内存中的地址。指向某个地方！ :-)

回复收藏 0 原文

丿*梦醉红颜 2024-07-30 23:08:47

是的，你是对的，无论是在速度还是内存方面。

指针几乎总是比标准int占用更多的字节，尤其是bool和char数据类型。在现代机器上，指针通常为 8 个字节，而 char几乎始终只有 1 个字节。

在此示例中，从 Foo 访问 char 和 bool 比从 Bar 访问需要更多的机器指令：

struct Foo
{
    char * c; // single character
    bool * b; // single bool
};

struct Bar
{
    char c;
    bool b;
};

。 .. 如果我们决定创建一些数组，那么 Foo 数组的大小将增大 8 倍 - 并且代码更加分散，因此这意味着您最终将得到一个更多缓存未命中。

#include <vector>

int main()
{
    int size = 1000000;
    std::vector<Foo> foo(size);
    std::vector<Bar> bar(size);

    return 0;
}

正如 dmckee 指出的，单字节 bool 的单个副本和指针的单个副本一样快：

bool num1, num2,* p1, * p2;
num1 = num2; // this takes one clock cycle
p1 = p2; // this takes another

正如 dmckee 所说，当您使用 64 位体系结构时确实如此。

但是，复制 int、bool 和 char 数组可能会快得多，因为我们可以将它们的多个压缩到每个寄存器上：

#include <iostream>

int main ()
{
    const int n_elements = 100000 * sizeof(int64_t);

    bool A[n_elements];
    bool B[n_elements];

    int64_t * A_fast = (int64_t *) A;
    int64_t * B_fast = (int64_t *) B;

    const int n_quick_elements = n_elements / sizeof(int64_t);

    for (int i = 0; i < 10000; ++i)
        for (int j = 0; j < n_quick_elements; ++j)
            A_fast[j] = B_fast[j];

    return 0;
}

STL 容器和其他优秀的库使用 type_traits (is_trivially_copyable) 和 std::memcopy 为我们做这类事情。假装指针总是一样快而使用指针会阻止这些库的优化。

结论：这些示例似乎很明显，但是当您需要获取/授予对原始对象的访问权限时，仅在基本数据类型上使用指针/引用。

Yes, you're right, both in terms of speed and memory.

Pointers almost always take up more bytes than your standard int and, especially, bool and char data types. On modern machines pointers typically are 8 bytes while char is almost always just 1 byte.

In this example, accessing the the char and bool from Foo requires more machine instructions than accessing from Bar:

struct Foo
{
    char * c; // single character
    bool * b; // single bool
};

struct Bar
{
    char c;
    bool b;
};

... And if we decide to make some arrays, then the size of the arrays of Foo would be 8 times larger - and the code is more spread-apart so this means you'll end up having a lot more cache misses.

#include <vector>

int main()
{
    int size = 1000000;
    std::vector<Foo> foo(size);
    std::vector<Bar> bar(size);

    return 0;
}

As dmckee pointed out, a single copy of a one-byte bool and a single copy of a pointer are just as fast:

bool num1, num2,* p1, * p2;
num1 = num2; // this takes one clock cycle
p1 = p2; // this takes another

As dmckee said, this is true when you're using a 64-bit architecture.

However, copying of arrays of ints, bools and chars can be much faster, because we can squeeze multiples of them onto each register:

#include <iostream>

int main ()
{
    const int n_elements = 100000 * sizeof(int64_t);

    bool A[n_elements];
    bool B[n_elements];

    int64_t * A_fast = (int64_t *) A;
    int64_t * B_fast = (int64_t *) B;

    const int n_quick_elements = n_elements / sizeof(int64_t);

    for (int i = 0; i < 10000; ++i)
        for (int j = 0; j < n_quick_elements; ++j)
            A_fast[j] = B_fast[j];

    return 0;
}

The STL containers and other good libraries do this sort of thing for us, using type_traits (is_trivially_copyable) and std::memcopy. Using pointers under the false guise that they're always just as fast can prevent those libraries from optimising.

Conclusion: It may seem obvious with these examples, but only use pointers/references on basic data types when you need to take/give access to the original object.

回复收藏 0 原文

胡大本事 2024-07-30 23:08:47

让我从基础开始。首先，您必须知道什么是变量以及它们如何使用。

变量基本上是内存位置（通常包含一些值），我们使用一些标识符（即变量名称）来引用该内存位置并使用该位置存在的值。

为了更好地理解它，假设我们想要来自与当前变量相关的某个位置的内存单元的信息。我们可以使用标识符从附近的单元格中提取信息吗？
不会。因为标识符（变量名称）只会给出该特定单元格中包含的值。

但是，如果我们能够以某种方式获得该变量所在的内存地址，那么我们可以轻松移动到附近的位置并使用它们的信息（在运行时）。

这就是指针发挥作用的地方。它们用于存储该变量的位置，以便我们可以在需要时使用附加地址信息。

语法：要存储变量的地址，我们可以简单地使用& (address-of) 运算符。

foo = &bar

这里 foo 存储变量 bar 的地址。

现在，如果我们想知道该地址上存在的值怎么办？

为此，我们可以简单地使用*（解除引用）运算符。

value = *foo

现在我们必须存储变量的地址，我们将像变量一样需要内存。这意味着指针也像其他变量一样存储在内存中，因此就像变量一样，我们也可以将指针的地址存储到另一个指针中。

Let me start from the basics. First of all, you will have to know what variable are and how they are used.

Variables are basically memory locations(usually containing some values) and we use some identifier(i.e., variable names) to refer to that memory location and use the value present at that location.

For understanding it better, suppose we want the information from memory cells present at some location relative to the current variable. Can we use the identifier to extract information from nearby cells?
No. Because the identifier(variable name) will only give the value contained in that particular cell.

But, If somehow we can get the memory address at which this variable is present then we can easily move to nearby locations and use their information as well(at runtime).

This is where pointers come into play. They are used to store the location of that variable so that we can use the additional address information whenever required.

Syntax: To store the address of a variable we can simply use & (address-of) operator.

foo = &bar

Here foo stores the address of variable bar.

Now, what if we want to know the value present at that address?

For that, we can simply use the * (dereference) operator.

value = *foo

Now that we have to store the address of a variable, we'll be needing the memory the same way as we need in case of a variable. This means pointers are also stored in the memory the same way as other variables, so just like in case of variables, we can also store the address of a pointer into yet another pointer.

回复收藏 0 原文