Início / coding / Perguntas / 79575336
Accepted
Gregorio Litenstein
Asked: 2025-04-15 21:56:51 +0800 CST

Existe uma maneira de fazer cast ao passar argumentos para uma função que deseja um ponteiro?

  • 772

Considere o seguinte cenário (comum) ao lidar com, por exemplo, OpenGL:

Você tem void glUseProgram(GLuint program);, assim como uma série de outras funções que exigem GLuint; mas não há glGetUint, você está preso a glGetInteger.

Então, digamos que você tem

class Foo() {
public:
    Foo::Foo() {
        glGetIntegerv(GL_CURRENT_PROGRAM, &program);
    }

private:
    GLuint program;
    void Bar();
};

Por literalmente mais de 10 anos em nosso projeto, tivemos um trecho de código semelhante e somente agora, sem realmente alterar a configuração, o compilador começou a reclamar sobre esta conversão específica:

error: implicit conversion changes signedness: 'GLint' (aka 'int') to 'GLuint' (aka 'unsigned int') [-Werror,-Wsign-conversion]

A solução é obviamente simples:

class Foo() {
public:
    Foo::Foo() {
        int _program;
        glGetIntegerv(GL_CURRENT_PROGRAM, &_program);
        program = static_cast<GLuint>(_program);
    }

private:
    GLuint program;
    void Bar();
};

Mas a questão é: posso fazer a mesma coisa em apenas uma etapa, sem precisar usar um int de escopo local no meio?

c++

2 respostas

  1. Best Answer

    Existe uma maneira de fazer cast ao passar argumentos para uma função que deseja um ponteiro?

    Acho que não é possível (pelo menos não com gesso).

    O problema é que glGetIntegervespera um ponteiro para um assinado GLint (geralmente um alias para int), enquanto programé um inteiro sem sinal .

    Teoricamente, você poderia se livrar do intermediário int _programusando uma conversão na chamada, algo como:

    glGetIntegerv(GL_CURRENT_PROGRAM, static_cast<GLint*>(&program));

    Mas isso não vai funcionar (como @TedLyngmo demonstrou em um comentário abaixo ) porque você não pode usar static_castfrom unsigned*para int*. reinterpret_cast, mas eu ficaria longe disso o máximo possível para evitar armadilhas do UB.

    Resumindo:
    acho que sua abordagem usando uma variável intermediária é uma boa solução.
    No entanto, eu criaria _programum GLintpara corresponder corretamente à API (embora geralmente seja um alias para, intde qualquer forma).

    • 5

  2. você pode fazer como std::inout_ptr faz e criar o inline temporário, que é o mais próximo que você pode chegar de apenas pegar o ponteiro sem violar nenhuma regra do C++.

    #include <iostream>
void function_taking_intptr(int* out)
{
    *out = 5;
}

template <typename T, typename IN>
auto wrap_as(IN& in_param)
{
    struct inout_object
    {
        IN& original_obj;
        T object;

        inout_object(IN& original)
            :original_obj{ original }, object{ static_cast<T>(original_obj) } {}
        operator T& () { return object; }
        operator T* () { return &object; }
        T* operator&() { return &object; }
        T& operator*() { return object; }
        ~inout_object() { original_obj = static_cast<IN>(object); }
        inout_object(const inout_object&) = delete;
        inout_object& operator=(const inout_object&) = delete;
    };
    return inout_object{in_param};
};

int main() {

    unsigned int my_int = 10;
    function_taking_intptr(wrap_as<int>(my_int));
    std::cout << my_int << '\n'; // 5
}

    demonstração online

    • 4

relate perguntas