小编Zos*_*oso的帖子

#include <iostream> gfhgfhgf
using namespace std;

int main() {
    return 0;
}

为什么这段代码片段会被编译？根据包含语法的gcc参考:

如果文件名后面的行上有任何内容(注释除外),则会出错.

而这正是代码中正在做的事情.

考虑这个带有片段的链接

#include <cstdio>

namespace X {
    extern "C" int z;
}

namespace Y {
    extern "C" int z;
}

int X::z = 1;
int main()
{
    std::printf("%d -- %d\n", X::z, Y::z);
    X::z = 2;
    Y::z = 4;
    std::printf("%d -- %d\n", X::z, Y::z);
    X::z = 0;
    std::printf("%d -- %d\n", X::z, Y::z);
}

带-O1GCC 输出

1 -- 1
2 -- 4
0 -- 0

而未启用优化的 GCC 的输出与 CLANG 的输出匹配（在所有优化级别），即

1 -- 1
4 -- 4
0 -- 0

这是 …

A）这有效：

int main() {
    int * a = new int[5];
    delete[] a;
    return 0;
}

B）这个错误：

int main() {
    int * a = new typeof(*a)[5];
    delete[] a;
    return 0;
}

出现错误：数组下标的类型“int[int]”无效

C）这有效：

int main() {
    int * a = new typeof(a)[5];
    delete[] a;
    return 0;
}

我不明白为什么 B 失败，因为扩展后的语句应该如下所示：

int *a = new int[5];

因为typeof(*a)是 int。

这是 decltype 的实验：

D）这不起作用：

int main() {
    int * a = new decltype(a)[5];
    delete[] a;
    return 0;
}

出现错误：无法在初始化时将 'int**' 转换为 'int*'。这是预期的，因为 …

在浏览一些内核代码时，我发现了一个内存对齐公式：

对齐 = ((操作数 + (对齐 - 1)) & ~(对齐 - 1))

所以我什至为此编写了一个程序：

#include <stdio.h>

int main(int argc, char** argv) {
    long long operand;
    long long alignment;
    if(argv[1]) {
        operand = atol(argv[1]);
    } else {
        printf("Enter value to be aligned!\n");
        return -1;
    }
    if(argv[2]) {
        alignment = strtol(argv[2],NULL,16);
    } else {
        printf("\nDefaulting to 1MB alignment\n");
        alignment = 0x100000;
    }
    long long aligned = ((operand + (alignment - 1)) & ~(alignment - 1));
    printf("Aligned memory is: 0x%.8llx [Hex] <--> %lld\n",aligned,aligned);
    return …

我试图根据文档在 Objective-C 中使用层托管视图

view.layer = [CALayer new];  // Create a layer-hosting view as opposed to a layer-backed view
view.wantsLayer = YES;

我继续使用此层托管视图通过使用 附加更多层来支持层的层次结构addSubLayer。

现在我的问题是是否可以CALayer在调试视图层次结构中查看这些子项/托管？我只看到NSViews 但看不到托管层。我正在寻找类似于 Visual Studio 中可用的东西实时视觉树，它显示平台视图和视觉层。

XCode 版本：11.3

我试图编译这段代码，但它在C++14运行时失败C++17

#include <cstdio>
#include <utility>

template <typename F>
struct S {
    explicit S(F&& fn): fn(std::move(fn)) {}
    F fn;
    ~S() { fn(); }
};


int main(){
    S obj([]() noexcept {
        std::printf("Foo\n");
    });                                                                                                 
}

我看到在 的C++17构造函数中S已被调用为

   call    S<main::{lambda()#1}>::S(main::{lambda()#1}&&)

这表明编译器推导了模板参数。C++14除了执行以下操作之外，还有其他方法可以编译此代码吗？

auto fn = []() noexcept {
    std::printf("Foo\n");
};
S<decltype(fn)> obj(std::move(fn)); 

https://kukuruku.co/post/i-do-not-know-c/

问题#7:

#include <stdio.h>
void f(int *i, long *l)
{
  printf("1. v=%ld\n", *l); /* (1) */
  *i = 11;                  /* (2) */
  printf("2. v=%ld\n", *l); /* (3) */
}
int main()
{
  long a = 10;
  f((int *) &a, &a);
  printf("3. v=%ld\n", a);
  return 0;
}

小端系统上两个不同编译器的输出是:

1. v=10    2. v=11    3. v=11
1. v=10    2. v=10    3. v=11

第二个结果怎么可能？我通过引用严格别名来解释结果的解释并不完全.编译器是否完全忽略第(2)行？

我正在尝试这个代码片段

#include <cstddef>
#include <cstdio>

void f(int* ptr){
    std::printf("int*\n");
}

void f(int val){
    std::printf("int\n");
}

int main() {
    f(NULL);
}

这在 GCC 和 CLANG 上都会出错，但 MSVC 会打印int。根据我对 的阅读，由于整型的[conv.ptr]空指针常量（实际上是NULL）可以转换为指针类型，因此编译器在选择适当的函数时应该是不明确的，因为它可以绑定到和。我确认所有这些编译器都已通过以下方式实现为整数类型intint*NULL

#if defined(_MSC_VER)
    static_assert(std::is_same<decltype(NULL), int>(), "");
#else
    static_assert(std::is_same<decltype(NULL), long>(), "");
#endif