user16217248's questions

De acordo com o Padrão C :

Cada tipo complexo tem os mesmos requisitos de representação e alinhamento de um tipo de matriz contendo exatamente dois elementos do tipo real correspondente; o primeiro elemento é igual à parte real e o segundo elemento à parte imaginária do número complexo.

Dessa forma, é possível lançar com segurança a _Complex float *em a float *e então acessar os componentes reais/imaginários usando o float *? Ou isso ainda violaria tecnicamente o aliasing estrito e, portanto, invocaria um comportamento indefinido?

_Complex float c;

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

c; // 1 + 2i

Tenho uma visualização SwiftUI que gostaria de poder mostrar uma das muitas outras visualizações diferentes :

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
                }
            }
        }
    }
}

Mas tem que haver alguma maneira de usar uma metaclasse para evitar a if elsecadeia longa.

Então tentei algo como:

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
                }
            }
        }
    }
}

Entretanto, isso não parece muito correto, pois recebo este erro para a showTypedeclaração:

O protocolo 'View' só pode ser usado como uma restrição genérica porque possui requisitos de tipo próprio ou associado

Acredito que isso seja porque Viewé um protocolo e não um tipo concreto, mas não tenho certeza de como contornar isso. Qual seria a sintaxe correta para fazer isso em Swift(UI)?

Em C, não há garantia de que o comportamento da aritmética de ponteiros reflita o comportamento da aritmética de inteiros se o ponteiro for convertido para um inteiro, até onde eu sei. Em outras palavras, não há garantia de que qualquer uma das afirmações abaixo será válida:

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);

Na maioria dos sistemas, isso será válido. Os bits finais da representação inteira de um ponteiro representarão o alinhamento do ponteiro, e adicionar um certo deslocamento a um ponteiro é o mesmo que adicionar o deslocamento vezes o tamanho do tipo de ponteiro à representação inteira do ponteiro.

No entanto, há alguma maneira de determinar, idealmente em tempo de compilação, se em qualquer implementação específica, essas suposições sempre serão verdadeiras para qualquer ponteiro, desde que a aritmética de ponteiros produzisse um ponteiro válido de qualquer maneira, já que o Padrão não as garante? Por exemplo, para falhar cedo em implementações sem suporte, recorrer a uma implementação alternativa, etc.

Tenho uma função que aceita um ponteiro mas não modifica os dados apontados, mas retorna o mesmo ponteiro ou uma derivada dele. Eu poderia fazer o ponteiro const:

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

Porém, isso significa que se eu chamar a função, não poderei manipular o resultado sem conversão, mesmo que o ponteiro que passei não fosse const. Pelo contrário, se eu fizer os ponteiros e retornar o tipo na função non constentão precisarei de um cast para passar qualquer ponteiro para a função que é const. E receberei um constponteiro de volta, então quebrei consta segurança.

Existe alguma maneira de criar uma função em C que respeite consta correção ( constentrada significa constsaída e não constentrada significa não constsaída) sem ter que escrever 2 funções separadas? Se não, quão perto posso chegar?

Nota: Este parece ser o tipo de pergunta que provavelmente já foi feita antes. Tentei procurar duplicatas usando palavras-chave como retorno de função const ou função de preservação de qualificador , mas não consegui encontrar nenhuma.

Em C, usar uma variável não inicializada é um comportamento indefinido. Incluindo:

int x;
int y = x;

No entanto, suponha que eu tenha o seguinte:

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

O código acima invoca um comportamento indefinido, no caso de alguns elementos, mas não todos, terem sido atribuídos?