标签: pointers

以下代码片段(正确)在C中发出警告,在C++中发出错误(分别使用gcc和g ++,使用版本3.4.5和4.2.1进行测试; MSVC似乎并不关心):

char **a;
const char** b = a;

我能理解并接受这个.
这个问题的C++解决方案是将b更改为const char*const*,它不允许重新分配指针并阻止你绕过const-correctness(C++ FAQ).

char **a;
const char* const* b = a;

但是,在纯C中,更正后的版本(使用const char*const*)仍会发出警告,我不明白为什么.有没有办法绕过这个而不使用演员？

澄清:
1)为什么这会在C中产生警告？它应该完全是const安全的,并且C++编译器似乎认识到它.
2)在说(并让编译器强制执行)我不会修改它指向的字符时,接受这个char**作为参数的正确方法是什么？例如,如果我想写一个函数:

void f(const char* const* in) {
  // Only reads the data from in, does not write to it
}

我想在char**上调用它,参数的正确类型是什么？

编辑:感谢那些做出回应的人,特别是那些提出问题和/或跟进我的回复的人.

我已经接受了这样一个答案,即如果没有演员阵容,我想做的事情是无法完成的,无论是否应该这样做.

什么是Null指针和Void指针之间的区别？

我正在解决 picoCTF 上的二进制开发挑战，并遇到了这段代码：

((void (*)())buf)();

哪里buf是字符数组。

我解决了挑战，但似乎无法理解它到底在做什么。我看着这个线程，但我无法理解。

什么((void (*)())buf)();意思？

有没有人对指针算术有任何好的文章或解释(博客,例子)？图中的观众是一群学习C和C++的Java程序员.

我可以知道C中不透明指针概念背后的用法和逻辑吗？

在检查另一个问题的引用时,我注意到C++ 11中的一个奇数子句,在[expr.rel]3:

指针void(后指针转化)可以进行比较,以确定其结果如下:如果两个指针表示相同的地址或均为空指针值,其结果是true,如果操作者 <=或>=与false其他方式; 否则结果未指定.

这似乎意味着,一旦两个指针被投入void *,它们的排序关系就不再有保证; 例如,这个:

int foo[] = {1, 2, 3, 4, 5};
void *a = &foo[0];
void *b = &foo[1];
std::cout<<(a < b);

似乎没有具体说明.

有趣的是,这个子句在C++ 03中不存在并且在C++ 14中消失了,所以如果我们采用上面的例子并应用C++ 14的措辞,我会说3.1

• 如果两个指针指向同一数组的不同元素或其子对象,则指向具有较高下标的元素的指针比较大.

将应用,作为a并b指向同一数组的元素,即使它们已被转换为void *.请注意,3.1的措辞在C++ 11中几乎完全相同,但似乎被该void *子句覆盖了.

我的理解是对的吗？在C++ 11中添加并立即删除的奇怪子句有什么意义？或者它可能仍然存在,但是被标准的其他部分移动/隐含？

C标准允许指向不同类型的指针具有不同的大小,例如sizeof(char*) != sizeof(int*)是允许的.但是,它确实要求如果指针转换为a void*然后转换回其原始类型,则必须将其与原始值进行比较.因此,从逻辑上讲,sizeof(void*) >= sizeof(T*)对于所有类型T,正确吗？

在当今使用的大多数常见平台上(x86,PPC,ARM和64位变体等),所有指针的大小都等于本机寄存器大小(4或8字节),而不管指向的类型.是否存在任何深奥或嵌入式平台,其中指向不同类型的指针可能具有不同的大小？我特别询问数据指针,虽然我也有兴趣知道是否存在函数指针具有异常大小的平台.

我绝对不会问C++的指向成员的指针和指向成员的指针函数.这些在常见平台上具有不寻常的大小,甚至可以在一个平台内变化,具体取决于指针类的属性(非多态,单继承,多继承,虚继承或不完整类型).

通过指针进行内存访问比通过数组进行内存访问更有效.我正在学习C,上面的内容在K&R中有说明.他们特别说

通过数组下标可以实现的任何操作也可以使用指针来完成.指针版本通常会更快

我使用visual C++解组了以下代码.(我是一个686处理器.我已禁用所有优化.)

int a[10], *p = a, temp;

void foo()
{
    temp = a[0];
    temp = *p;
}

令我惊讶的是,我看到通过指针的内存访问需要通过数组对内存访问所采用的两条指令.以下是相应的代码.

; 5    : temp = a[0];

    mov eax, DWORD PTR _a
    mov DWORD PTR _temp, eax

; 6    : temp = *p;

    mov eax, DWORD PTR _p
    mov ecx, DWORD PTR [eax]
    mov DWORD PTR _temp, ecx

请帮我理解.我在这里失踪了什么？

正如许多答案和评论所指出的那样,我使用了编译时常量作为数组索引,从而使得通过数组访问变得更容易.下面是汇编代码,其中变量作为索引.我现在有相同数量的指令通过指针和数组进行访问.我更广泛的问题仍然很好.通过指针进行内存访问并不会使其本身更有效.

; 7    :        temp = a[i];

    mov eax, DWORD PTR _i
    mov ecx, DWORD PTR _a[eax*4]
    mov DWORD PTR _temp, …

我在几个旧项目中看到过这样的代码:

class Class {
    static void Method() {}
};

((Class*)0)->Method();

此代码包含未定义的行为,因为它包括取消引用空指针(无论之后发生什么).这真的没有意义 - 演员是在那里将类型名称提供给编译器,并且编写上面代码的人可以写这个:

Class::Method();

而后者也没关系.

为什么有人会写前代码？它是来自一些美好时光的已知成语还是什么？

这是一个初学者的问题,但我很长一段时间没有做过C++,所以这里......

我有一个包含动态分配数组的类,比方说

class A
{
    int* myArray;
    A()
    {
        myArray = 0;
    }
    A(int size)
    {
        myArray = new int[size];
    }
    ~A()
    {
        // Note that as per MikeB's helpful style critique, no need to check against 0.
        delete [] myArray;
    }
}

但现在我想创建一个动态分配的这些类的数组.这是我目前的代码:

A* arrayOfAs = new A[5];
for (int i = 0; i < 5; ++i)
{
    arrayOfAs[i] = A(3);
}

但这种情况非常糟糕.因为在循环迭代完成时,A(通过A(3)调用)创建的新对象会被破坏for,这意味着myArray该A实例的内部delete []变为-ed.

所以我认为我的语法必定是非常错误的？我想有一些看起来像矫枉过正的修复,我希望避免:

• 为...创建复制构造函数A …