Início / coding / Perguntas / 79583164
Accepted
DannyNiu
Asked: 2025-04-20 16:15:13 +0800 CST

UB ao passar uma matriz multidimensional de uma forma para parâmetro de função esperando outra

  • 772

Estou analisando o rascunho C2Y n3467 e tentando entender algo envolvendo funções que utilizam VLAs.

Parece haver um comportamento indefinido que não é mencionado pela norma. Ou seja:

  • passando uma matriz multidimensional de uma extensão particular para
  • um parâmetro de função esperando um, onde
  • a definição da função espera uma extensão diferente.

Aqui está meu código demonstrando isso. Embora o comportamento resultante tenha feito sentido, não entendo ( Q :) por que o padrão nunca declarou esse comportamento indefinido/não especificado/definido pela implementação. Nas seções específicas, 6.7.7.3. Array e 6.7.7.4. Declaradores de Função na seção 6.7. Declaração, e 6.9.2. Definições de Função na seção Declarações Externas, a possível UB não é mencionada em nenhum lugar nesses lugares.

#include <stdio.h>
#include <stdlib.h>

extern int d, e;
int g(int z[3][*][*]);

int main()
{
    int z[3][d][e];
    for(int i=0; i<3; i++)
        for(int j=0; j<d; j++)
            for(int k=0; k<e; k++)
                z[i][j][k] = i*d*e+j*e+k;
    int x = g(z);
    printf("%zd, %d.\n", sizeof(float[x]), x);
    return 0;
}

extern int u, v;
int g(int z[3][v][u])
{
    return z[0][2][2];
}

As variáveis ​​externas são definidas assim:

int u = 3, v = 5;
int d = 7, e = 7;

Saída:

32, 8.
c

1 respostas

  1. Best Answer

    A seção 6.5.3.3 parágrafo 6 descreve como os argumentos são convertidos em uma chamada de função:

    Os argumentos são convertidos implicitamente, como se por atribuição, para os tipos dos parâmetros correspondentes, tomando o tipo de cada parâmetro como a versão não qualificada do seu tipo declarado...

    Após a conversão de array para ponteiro e o ajuste automático dos tipos de argumentos de função declarados, g(z)chama uma função com parâmetro do tipo int (*)[v][u], passando um argumento do tipo int (*)[d][e]. O tipo do argumento é convertido para o tipo do parâmetro como se fosse uma atribuição.

    Então, está tudo bem em executar essa tarefa?

    Bem, as restrições à atribuição são descritas na seção 6.5.17.2, parágrafo 1. A seção relevante é a seguinte:

    o operando esquerdo tem tipo de ponteiro atômico, qualificado ou não qualificado e (considerando o tipo que o operando esquerdo teria após a conversão de lvalue) ambos os operandos são ponteiros para versões qualificadas ou não qualificadas de tipos compatíveis, e o tipo apontado pelo operando esquerdo tem todos os qualificadores do tipo apontado pelo operando direito;

    Portanto, esses ponteiros precisam apontar para versões qualificadas ou não qualificadas de tipos compatíveis. Será que é isso mesmo?

    Bem, a seção 6.7.7.3 parágrafo 6 diz o seguinte:

    Para que dois tipos de array sejam compatíveis, ambos devem ter tipos de elementos compatíveis e, se ambos os especificadores de tamanho estiverem presentes e forem expressões constantes inteiras, ambos os especificadores de tamanho devem ter o mesmo valor constante. Se os dois tipos de array forem usados ​​em um contexto que exija compatibilidade, o comportamento será indefinido se os dois especificadores de tamanho forem avaliados como valores diferentes.

    Os tipos de array int [v][u]e int [d][e]estão sendo usados ​​em um contexto que exige compatibilidade, mas os especificadores de tamanho não correspondem. O comportamento é indefinido.

    • 5

relate perguntas