Início / coding / Perguntas / 79558268
Accepted
Zebrafish
Asked: 2025-04-06 21:31:38 +0800 CST

Como os "tipos" têm ligação externa ou interna? Por que isso tem ligação interna?

  • 772

Eu sei que variáveis/objetos têm ligação interna e externa, mas não sabia que "tipos" têm ligação interna e externa. Quando compilo meu código com o GCC, recebo o aviso:

'ShaderModuleObject' tem um campo 'GFXAPIShaderModuleHandle ShaderModuleObject::handle' cujo tipo tem ligação interna [-Wsubobject-linkage]

Aqui está o código, e eu o colei no Godbolt , mas não vejo o mesmo aviso, ou mesmo se o Godbolt tem avisos habilitados:

#define GFX_API_NULL_HANDLE 0

template <typename T, void(*deleter)(T)>
struct MoveOnlyGFXAPIHandle
{
    MoveOnlyGFXAPIHandle() : handle(GFX_API_NULL_HANDLE) {}
    MoveOnlyGFXAPIHandle(T handle) : handle(handle) {}
    MoveOnlyGFXAPIHandle(const MoveOnlyGFXAPIHandle&) = delete;
    MoveOnlyGFXAPIHandle(MoveOnlyGFXAPIHandle&& other) : handle(other.handle) { other.handle = GFX_API_NULL_HANDLE; };
    MoveOnlyGFXAPIHandle& operator=(const MoveOnlyGFXAPIHandle&) = delete;
    MoveOnlyGFXAPIHandle& operator=(MoveOnlyGFXAPIHandle&& other)
    {
        this->reset();
        handle = other.handle;
        other.handle = GFX_API_NULL_HANDLE;

        return *this;
    }
    void reset() { 
        if (handle != GFX_API_NULL_HANDLE) 
        {
            deleter(this->handle); 
            handle = GFX_API_NULL_HANDLE; 
        }    
    }
    
    void assign(T handle) { reset(); this->handle = handle; }
    operator T() const { return handle; }

    T get() const { return handle; }
    ~MoveOnlyGFXAPIHandle() { 

        reset(); }
private:
    T handle;
};


using GFXAPIShaderModuleHandle = MoveOnlyGFXAPIHandle < int,
    +[](int handle) {

          //destroyShaderModule(handle);
    } > ;




struct ShaderModuleObject {

    GFXAPIShaderModuleHandle handle;
};


int main()
{

    ShaderModuleObject module_object;


    return 0;
}

O que são tipos com ligação interna e externa? E por que meu tipo tem ligação interna, e por que isso é algo ruim a ponto de o GCC me alertar sobre isso?

c++

1 respostas

  1. Best Answer

    Aqui está o MCVE:

    // header.hpp

// a pointer to function is used as non-type template parameter
template <void ( * x_dummy )(void)>
struct Foo
{
};

// non-capturing lambda converted to pointer to function with unary + operator
using Bar = Foo< +[](void) { return; } >; 

struct Frob
{
    Bar bar;
};

    // main.cpp
#include "header.hpp"

int main()
{
    return 0;
}

    g++ -c --std=c++20 ./main.cpp
In file included from ./main.cpp:1:
./header.hpp:10:8: warning: ‘Frob’ has a field ‘Bar Frob::bar’ whose type has internal linkage [-Wsubobject-linkage]
   10 | struct Frob
      |        ^~~~

    O que está acontecendo aqui? O tipo com alias de Barpossui ligação interna, pois pode ser referenciado apenas pelo nome da unidade de tradução atual. Isso acontece porque ele usa lambda (que, aliás, é anônimo, não pode ser referenciado pelo nome e, portanto, não possui ligação) e a inclusão header.hem uma unidade de tradução diferente resultará na produção de um tipo diferente e na violação do ODR para Frob.

    Este exemplo é bastante inofensivo (sem problemas, já que há apenas uma unidade de tradução), mas em cenários mais complexos, isso pode levar a bugs estranhos e mensagens de erro confusas. Por exemplo, se Barfor usado como parte da interface DLL, o nome do símbolo corrompido pode ser diferente, dependendo da unidade de tradução onde o cabeçalho está incluído, produzindo erros de linker crípticos:

    __attribute__((visibility("default"))) void
Drob(Bar *);

    // imported symbol
Drob(Foo<&{__lambda__#123()}::_FUN>*)

    // exported symbol
Drob(Foo<&{__lambda__#456()}::_FUN>*)

    Outro MCVE onde esse tipo de problema resulta em um erro HARD em vez de um aviso:

    // header.hpp
#pragma once

template <void ( * x_deleter )(void)>
struct Foo
{
};

using Bar = Foo< +[](void) { return; } >;

void Drob(Bar *);

    // header.cpp
#include "header.hpp"

void Drob(Bar *)
{
    return;
}

    // main.cpp
#include "header.hpp"

int main()
{
    Drob(nullptr);
    return 0;
}

    g++ --std=c++20 -Wall ./main.cpp ./header.cpp 
In file included from ./main.cpp:1:
./header.hpp:10:6: warning: ‘void Drob(Bar*)’ used but never defined
   10 | void Drob(Bar *);
      |      ^~~~
./header.cpp:3:6: warning: ‘void Drob(Bar*)’ defined but not used [-Wunused-function]
    3 | void Drob(Bar *)
      |      ^~~~
/usr/bin/ld: /tmp/ccY7YKJR.o: in function `main':
main.cpp:(.text+0xe): undefined reference to `Drob(Foo<&{lambda()#1}::_FUN>*)'
collect2: error: ld returned 1 exit status
    • 2

relate perguntas