当两个指针进行比较时，结果取决于所指向的对象在地址空间中的相对位置。如果指向对象或不完整类型的两个指针都指向同一个对象，或者都指向同一个数组对象的最后一个元素之后的一个，则它们比较相等。如果指向的对象是同一个聚合对象的成员，则指向后面声明的结构体成员的指针比较大于指向结构体中前面声明的成员的指针，指向下标值较大的数组元素的指针比较大于指向同一数组元素的指针具有较低的下标值。指向同一联合对象成员的所有指针比较相等。如果表达式 P 指向数组对象的一个元素，并且表达式 Q 指向同一数组对象的最后一个元素，则指针表达式 Q+1 比较结果大于 P。在所有其他情况下，行为未定义。
如果我们有两个引用相同类型数组的指针，并且我们有这些数组的长度，我们是否可以在不调用 UB 的情况下找到这些数组是否不重叠？
备注：我对向我展示在现实生活中（实施等）可以做到的例子不感兴趣。因此，请不要显示代码（除非您可以[标准地]证明 UB 是免费的）。
代码：
#define OPPOSITE(c) (*((typeof(x) *)&(x)))
int foo(volatile int x)
{
OPPOSITE(x) = OPPOSITE(x) + OPPOSITE(x);
return x;
}
int bar(volatile int x)
{
OPPOSITE(x) = OPPOSITE(x) + OPPOSITE(x);
return x;
}
结果（-Os）：
foo:
mov DWORD PTR [rsp-4], edi
mov eax, DWORD PTR [rsp-4]
mov edx, DWORD PTR [rsp-4]
add eax, edx
mov DWORD PTR [rsp-4], eax
mov eax, DWORD PTR [rsp-4]
ret
bar:
mov DWORD PTR [rsp-4], edi
mov eax, DWORD PTR [rsp-4]
add eax, eax
ret
或ARM gcc。( -O3 …
非常简单的代码：
void *allocateMemory5DArray(size_t x, size_t y, size_t z, size_t q, size_t r)
{
int (*array)[x][y][z][q][r];
array = malloc(sizeof(*array));
return array;
}
-O0gcc需要 296 字节的堆栈，生成的代码长度 > 180 行。任何人都可以解释其背后的原理吗？
其他编译器（除了 clang）也会生成奇怪的代码，但不像gcc:)
这些表达式有定义吗？
int x = 5, y;
y = ++(int){++x};
//or
y = (int){x++}++;
并且（我找不到任何不被定义的理由）
int x = 5;
x = ++(int){++x};
//or
x = (int){x++}++;
IMO 有明确的序列点来创建新对象（复合文字）。
被NULL - NULL定义为。？
被(char *)NULL - (char *)NULL定义为。？
被(uintptr_t)NULL - (uintptr_t)NULL定义为？
我知道它适用于我使用的所有实现。但从标准的角度来看，它是什么样子的呢？我找不到明确的答案。
编辑：从骗子看来，我认为问题的一个答案是：是的。
那么第二个问题和第三个问题呢？
C标准的语言有时不是很清晰和一致。
calloc和使用不同的措辞malloccalloc：“calloc函数为一个arraynmemb对象分配空间，每个对象的大小为size。”malloc: “malloc函数为大小由size指定的对象分配空间”一般来说，数组也是一个对象。
我正在寻找精确的答案 - 而不是一般常识性的思考和现实生活中的用法。
我收到错误：
An unhandled exception of type 'System.Text.Json.JsonException' occurred in System.Text.Json.dll
',' is invalid after a single JSON value. Expected end of data. Path: $ | LineNumber: 10 | BytePositionInLine: 2.
代码：
public class InstrumentData
{
//[JsonInclude]
//[JsonPropertyName("Id")]
public int Id { get; set; }
//[JsonInclude]
//[JsonPropertyName("Type")]
public string Type { get; set; }
//[JsonInclude]
//[JsonPropertyName("Kind")]
public string Kind { get; set; }
//[JsonInclude]
//[JsonPropertyName("Date")]
public DateTime Date { get; set; }
//[JsonInclude]
//[JsonPropertyName("Status")]
public string Status { get; set; } …许多程序都假设sizeof(int)==sizeof(unsigned int). IMO 不是，我在标准中找不到任何保证它的内容。我是对还是错？
有时它等待的时间不够长。我可能错过了一些简单的东西 - 但我找不到它。为什么等待函数有时会过早返回
#define SEMAPHORE_MAXWAIT -1
#define SEMAPHORE_NOWAIT 0
// Type your code here, or load an example.
typedef struct binary_semaphore {
pthread_mutex_t mutex;
pthread_cond_t condvar;
bool variable;
}binary_semaphore_t;
static struct timespec *timespec_addms(struct timespec *ts, unsigned ms)
{
uint64_t nsec;
if(ts)
{
ts -> tv_sec += ms / 1000;
nsec = ts -> tv_nsec + (ms % 1000) * 1000000ULL;
ts -> tv_sec += nsec / 1000000000ULL;
ts -> tv_nsec = nsec % 1000000000ULL;
}
return ts;
}
static int …我有一个 C++ 程序：
#include <iostream>
char * foo (char * bar, const char * baz) {
int i = -1;
do {
i++;
*(bar + i) = *(baz + i);
} while (*(baz + i));
return bar;
}
int main (int argc, char *argv[]) {
char bar[] = "";
char baz[] = "Hello";
foo(bar, baz);
std::cout << "bar: " << bar << std::endl;
std::cout << "baz: " << baz << std::endl;
}
并不是说这是重要的部分，而是该程序的要求是它使用指针将一个C 样式字符串复制到另一个。
当我在 Ubuntu 16.04 桌面上编译并执行我的二进制文件时，我看到的是： …