我对解除引用操作符,操作符的地址和一般指针有相当好的理解.

但是当我看到这样的东西时,我感到很困惑:

int* returnA() {
    int *j = &a;
    return j;
}

int* returnB() {
    return &b;
}

int& returnC() {
    return c;
}

int& returnC2() {
    int *d = &c;
    return *d;
}

1. 在returnA()我要求返回一个指针; 只是为了澄清这个作品因为j是一个指针？
2. 在returnB()我要求返回一个指针; 因为指针指向一个地址,所以returnB()工作的原因是因为我回来了&b？
3. 在returnC()我要求int归还的地址.当我返回时c,&操作员会自动"追加" c吗？
4. 在returnC2()我再问一个int要归还的地址.是否*d有效,因为指针指向一个地址？

假设a,b,c被初始化为整数为Global.

有人可以验证我的所有四个问题是否正确？

如何0x28ff44用C编程语言手动分配指针地址(例如到存储器地址)？

背景

我创建了一个主要用于学习目的的基本链表数据结构.该列表的一个目标是它可以处理不同的数据结构.因此,我已尝试在结构组合中模拟C中的"继承".以下是构成我的链表的基础的结构.

typedef struct Link {
    struct Link* next;
    struct Link* prev;
} Link;

typedef Link List;

在我的实现中,我选择了一个作为列表头部和尾部的Sentinel节点(这就是Link == List的原因).

为了使列表实际处理数据,结构只包含Link结构作为第一个成员:

typedef struct {
    Link link;
    float data;
} Node;

所以链表看起来像这样.

         ?????????????     ?????????     ?????????????     
... <--->? P ? N ? D ?<--->? P ? N ?<--->? P ? N ? D ?<---> ... 
         ?????????????     ?????????     ?????????????
         End Node          myList        First Node

List myList;
Node node1 = {{}, 1.024};
....
Node nodeN = {{}, 3.14};

list_init(&myList) // myList.next = &myList; myList.prev …

我对以下代码感到有点困惑:

#include <iostream>

const char* f()
{
    const char* arr[]={"test"};
    return arr[0];
}

int main()
{
    auto x = f();
    std::cout << x;
}

在我看来,这段代码应该是UB(未定义的行为).我们返回一个指向本地范围内的C风格数组元素的指针.事情应该出问题.但是,我测试过的编译器都没有抱怨(我用过-Wall -Wextra -pedanticg ++和clang).valgrind也不抱怨.

上面的代码是有效的还是人们会想到的UB？

PS:运行它似乎产生"正确"的结果,即显示"测试",但这并不表示正确性.

正如标题所说,有什么区别

char a[] = ?string?; and 
char *p = ?string?;  

这个问题在接受我采访时被问到了.我甚至不理解这个说法.

char a[] = ?string?

什么是?运营商？它是字符串的一部分还是具有某些特定含义？

所以我想在制作函数指针时,你不需要operator &获取初始函数的地址:

#include <stdio.h>

double foo (double x){
    return x*x;
}

int main () {

    double (*fun1)(double) = &foo;
    double (*fun2)(double) =  foo;

    printf("%f\n",fun1(10));
    printf("%f\n",fun2(10));

    printf("fun1 = %p \t &foo = %p\n",fun1, &foo);
    printf("fun2 = %p \t  foo = %p\n",fun2,  foo);       

    int a[10];

    printf("  a = %p \n &a = %p  \n",a,&a);

    return 0;
}

输出:

>./a.out 
100.000000
100.000000
fun1 = 0x4004f4      &foo = 0x4004f4
fun2 = 0x4004f4       foo = 0x4004f4
  a = 0x7fff26804470 
 &a = 0x7fff26804470 

然后我意识到这对于数组也是如此,这意味着如果你有 …

考虑以下代码(以及VirtualAlloc()返回avoid*的事实):

BYTE* pbNext = reinterpret_cast<BYTE*>(
    VirtualAlloc(NULL, cbAlloc, MEM_COMMIT, PAGE_READWRITE));

为什么reinterpret_cast选择而不是static_cast？

我以前认为reinterpret_cast可以用于例如从整数类型(例如DWORD_PTR)转换指针,但是从a转换void*为a BYTE*,是不是static_cast可以？

在这种特殊情况下是否存在任何(微妙的？)差异,或者它们是否只是有效的指针转换？

C++标准是否偏爱这种情况,建议采用一种方式而不是另一种方式？

在我的项目中有一个方法只返回一个const char*,而我需要一个char*字符串,因为API不接受const char*.

知道怎么转换const char*到char*？

对于指针变量p,p <(p + 1)是否为假是否可能？请解释一下你的答案.如果是,在哪种情况下会发生这种情况？

我想知道p + 1是否会溢出并且等于0.

例如,在64位PC上使用GCC-4.8进行C语言程序:

int main(void) {
   void *p=(void *)0xFFFFFFFFFFFFFFFF;

   printf("p      :%p\n", p);
   printf("p+1    :%p\n", p+1);
   printf("Result :%d\n", p<p+1);
}

它返回:

p      : 0xffffffffffffffff
p+1    : (nil)
Result : 0

所以我相信这种情况是可能的.对于无效的指针位置,它可能发生.这是我能想到的唯一解决方案.还有其他人吗？

注意: 不做任何假设.考虑任何可能发生这种情况的编译器/平台/架构/操作系统.

在执行指针算术时有很多未定义/未指定行为的示例 - 指针必须指向同一个数组(或者一个超过结尾),或者在同一个对象内,限制何时可以根据上述进行比较/操作等

以下操作定义明确吗？

int* p = 0;
p++;