主页 / user-16217248

user16217248's questions

Martin Hope
CPlus
Asked: 2025-03-07 09:44:45 +0800 CST
  • 9

根据C 标准：

每个复数类型都具有与包含相应实数类型的两个元素的数组类型相同的表示和对齐要求；第一个元素等于复数的实部，第二个元素等于复数的虚部。

因此，是否可以安全地将 a 转换_Complex float *为 a float *，然后使用 访问实部/虚部float *？或者这在技术上是否仍违反严格别名，从而引发未定义的行为？

_Complex float c;

((float *)&c)[0] = 1;
((float *)&c)[1] = 2;

c; // 1 + 2i
c
Martin Hope
CPlus
Asked: 2025-03-03 05:04:38 +0800 CST
  • 5

我有一个 SwiftUI 视图，我希望能够显示许多其他不同视图之一：

struct View1: View {
    var body: some View {
        Text("View1")
    }
}

struct View2: View {
    var body: some View {
        Text("View2")
    }
}

struct View3: View {
    var body: some View {
        Text("View3")
    }
}

struct View4: View {
    var body: some View {
        Text("View4")
    }
}

struct ContentView: View {
    @State var showView1 = false
    @State var showView2 = false
    @State var showView3 = false
    @State var showView4 = false

    @ViewBuilder var body: some View {
        if (showView1) {
            View1()
        } else if (showView2) {
            View2()
        } else if (showView3) {
            View3()
        } else if (showView4) {
            View4()
        } else {
            VStack {
                Button ("Show View1") {
                    showView1 = true
                }
                Button ("Show View2") {
                    showView2 = true
                }
                Button ("Show View3") {
                    showView3 = true
                }
                Button ("Show View4") {
                    showView4 = true
                }
            }
        }
    }
}

但必须有某种方法来使用元类来避免长if else链。

所以我尝试了类似的事情：

struct ContentView: View {
    @State var showType: View.Type? = nil

    @ViewBuilder var body: some View {
        if let showType = showType {
            showType.init()
        } else {
            VStack {
                Button ("Show View1") {
                    showType = View1.type
                }
                Button ("Show View2") {
                    showType = View2.type
                }
                Button ("Show View3") {
                    showType = View3.type
                }
                Button ("Show View4") {
                    showType = View4.type
                }
            }
        }
    }
}

然而，这似乎不太正确，因为我收到此showType声明错误：

协议“View”只能用作通用约束，因为它具有自身或关联类型要求

我相信这是因为View它是一种协议而不是具体类型，但我不确定如何解决这个问题。在 Swift(UI) 中执行此操作的正确语法是什么？

swift
Martin Hope
CPlus
Asked: 2024-09-03 05:09:15 +0800 CST
  • 7

据我所知，在 C 语言中，如果将指针转换为整数，则无法保证指针运算的行为反映整数运算的行为。换句话说，无法保证以下任何断言都成立：

char a[2]; // So that p + 1 is a valid memory location
char *p = a;
assert(p + 1 == (char *)((uintptr_t)p + 1));

int x;
int *p = &x;
assert((intptr_t)p % sizeof(int) == 0);

在大多数系统中，这些都会成立。指针的整数表示的尾部位将表示指针对齐，并且向指针添加某个偏移量与将偏移量乘以指针类型的大小添加到指针的整数表示中相同。

但是，有没有办法确定，最好是在编译时，在任何特定的实现中，这些假设是否对任何指针都始终成立，只要指针算法无论如何都会产生一个有效的指针，因为标准不保证它们？例如，在早期不支持的实现上失败，回退到替代实现等。

c
Martin Hope
user16217248
Asked: 2023-11-21 02:33:18 +0800 CST
  • 8

我有一个函数，它接受指针但不修改指向的数据，但返回相同的指针或其派生。我可以做指针const：

const void *some_read_only_operation(const void *ptr) {
    // Do work with ptr
    return ptr;
}

但是，这意味着如果我调用该函数，即使我传递的指针不是 ，我也将无法在不进行强制转换的情况下操纵结果const。相反，如果我在函数中设置指针和返回类型为 non ，const那么我将需要进行强制转换以将任何指针传递给函数const。我会得到一个非const指针，所以我破坏了const安全性。

有没有什么方法可以在 C 中创建一个尊重const正确性的函数（constin 表示constout，non constin 表示 non constout），而不必编写 2 个单独的函数？如果没有，我能接近多远？

注意：这似乎是以前可能被问过的问题类型。我尝试使用const function return或限定符保留函数等关键字搜索重复项，但找不到任何重复项。

c
Martin Hope
user16217248
Asked: 2023-09-07 02:26:24 +0800 CST
  • 5

在 C 中，使用未初始化的变量是未定义的行为。包括：

int x;
int y = x;

但是，假设我有以下内容：

struct Struct {
    int a;
    int b;
};
struct Struct s;
s.a = 1;
struct Struct s0 = s;
return s; // Assuming an enclosing function with the correct return type

如果某些元素（但不是全部）已被分配，上述代码是否会调用未定义的行为？

c