Thomas Weller's questions

Clang-format diz sobre QualifierAlignment :

Aviso

Definir QualifierAlignmentalgo diferente de Leave, PODERIA levar a uma formatação incorreta do código devido a decisões incorretas tomadas devido à falta de informações semânticas completas do clang-formats. Como tal, deve-se tomar cuidado extra ao revisar as alterações do código feitas pelo uso desta opção.

Gostaria de ver um código de exemplo de quando isso acontece, para que eu saiba melhor o que devo procurar em revisões de código. Tentei várias opções diferentes, de variáveis ​​sobre parâmetros a funções de membro const e modelos - clang-format acertou em todas elas.

Em duração do armazenamento , li que o armazenamento de registro foi descontinuado por um longo tempo (desde o C++98) e foi removido com o C++17.

Ainda assim, o compilador ainda pode colocar variáveis ​​em um registrador. Eu assumo que ele fará isso como parte da duração de armazenamento automático :

Duração do armazenamento automático

As seguintes variáveis ​​têm duração de armazenamento automática:

Variáveis ​​que pertencem a um escopo de bloco e não são explicitamente declaradas como static, thread_local, (desde C++11) ou extern. O armazenamento para tais variáveis ​​dura até que o bloco no qual elas são criadas saia. Variáveis ​​que pertencem a um escopo de parâmetro (ou seja, parâmetros de função). O armazenamento para um parâmetro de função dura até imediatamente após sua destruição.

Para mim, parece que essa descrição é satisfeita para ambas, variáveis ​​na pilha e variáveis ​​em registradores, dado um aplicativo Windows Desktop e MSVC. Isso está correto?

Só quero usar o termo correto quando falo com meus colegas e estou explicitamente procurando por algo que possa significar "pilha ou registro".

Estou tentando entender a opção "Biblioteca de Tempo de Execução" do Microsoft Visual Studio C++.

De acordo com /MD, /MT, /LD (Use Run-Time Library) [MS Learn] , há 6 opções. Essas são essencialmente 3 opções que vêm em Debug e Release flavor.

Onde defino a opção /LD?

O site diz:

1. Abra a caixa de diálogo Property Pages do projeto. Para obter detalhes, consulte Definir propriedades de compilação e compilação do C++ no Visual Studio.
2. Selecione a página de propriedades Propriedades de configuração > C/C++ > Geração de código.
3. Modifique a propriedade Biblioteca de Tempo de Execução.

Nesse lugar, meu Visual Studio só oferece /MD, /MT, /MDd e /MTd. Não há opção /LD ou /LDd disponível.

Desta declaração em /LD:

Implica /MT, a menos que você especifique explicitamente /MD.

Concluo que essas devem ser opções diferentes, caso contrário eu não poderia especificar /LD e /MD ao mesmo tempo.

Estou usando o Visual Studio 2022 Preview, versão 17.13.0 Preview 2.1. Meu tipo de projeto é uma "Biblioteca de vínculo dinâmico (DLL)". Propriedades de configuração / Geral / Tipo de configuração diz "Biblioteca dinâmica (.dll)".

Estes são todos os argumentos da linha de comando do compilador se eu especificar /MT para a configuração de depuração:

/JMC /permissive- /Yu"pch.h" /ifcOutput "x64\Debug\" /GS /W3 /Zc:wchar_t 
/ZI /Gm- /Od /sdl /Fd"x64\Debug\vc143.pdb" /Zc:inline /fp:precise 
/D "_DEBUG" /D "DYNAMICLIBRARY_EXPORTS" /D "_WINDOWS" /D "_USRDLL" /D "_WINDLL" 
/D "_UNICODE" /D "UNICODE" 
/errorReport:prompt /WX- /Zc:forScope /RTC1 /Gd /MT /FC /Fa"x64\Debug\" /EHsc 
/nologo /Fo"x64\Debug\" /Fp"x64\Debug\DynamicLibrary.pch" /diagnostics:column 

Por quê? Este exemplo [MSDN] diz que eu deveria compilar usando cl /EHsc /W4 /MD /LD test1Dll.cpp. Eu sei, eu poderia fazer isso na linha de comando ou adicionar /LDas opções de linha de comando adicionais da IU. Mas eu quero entender melhor e não apenas seguir algumas instruções às cegas.

Dado o seguinte código envolvendo operator new[]e as várias versões erradas de delete:

#include <iostream>

class Test {
public:
    Test()  { std::cout << "Test()\n";  }
    ~Test() { std::cout << "~Test()\n"; }
};

int main()
{
    void* p = operator new[](10 * sizeof(Test));
    Test* test = new (p) Test();
    test->~Test();
    // delete p; // UB1
    // delete[] p; // UB2
    // delete[] test; // UB3
    // operator delete[](test); // UB4?
    operator delete[](p);
    std::cout << "End\n";
}

_{ao vivo em https://godbolt.org/z/zG3nfzsv6}

Você poderia explicar por que UB2 a UB4 são comportamentos indefinidos, com alguma explicação em termos leigos do padrão C++20 rascunho N4861, §7.6.2.8 [expr.delete] e talvez §7.6.2.7 [expr.new]?

Aqui está minha tentativa. Estou bem confiante sobre UB1, mas não muito confiante sobre UB2 e UB3, e menos ainda sobre UB4.

UB1

(ênfase minha)

§ 7.6.2.8 (1)

excluir-expressão:
::optar excluir expressão-cast
::optar excluir [ ] expressão-cast

A primeira alternativa é uma expressão de exclusão de objeto único , e a segunda é uma expressão de exclusão de matriz.

§ 7.6.2.8 (2)

Em uma expressão delete de objeto único , o valor do operando de delete pode ser um valor de ponteiro nulo, um ponteiro para um objeto não array criado por uma new-expression anterior ou um ponteiro para um subobjeto (6.7.2) representando uma classe base de tal objeto (11.7). Caso contrário, o comportamento é indefinido.

Então, para deletesem []eu não devo usar um ponteiro de array. Mas eu usei, então eu tenho UB. Ótimo.

UB2 para UB4

(ênfase minha)

Em uma expressão de exclusão de matriz , o valor do operando de exclusão pode ser um valor de ponteiro nulo ou um valor de ponteiro que resultou de uma nova expressão de matriz anterior . ⁷⁴ Caso contrário, o comportamento será indefinido.

Bem, eu tenho uma matriz de uma nova expressão anterior.

[Nota: Isso significa que a sintaxe da expressão delete deve corresponder ao tipo do objeto alocado por new, não à sintaxe da nova expressão . — nota final]

_{Pergunta paralela: Por que isso significa isso?}

Ok, então eu tenho operator new[]e esta nota me diz que a sintaxe do meu delete pode ser diferente. Eu não preciso necessariamente, operator delete[]mas algo que corresponda ao tipo do objeto.

_{Pergunta lateral: Qual é o tipo do meu objeto? Meu ponteiro p é void*, mas voidnão é um tipo de objeto. p aponta para a void[]e void[]é um tipo de objeto?}

§ 7.6.2.8 (11)

Para uma expressão de exclusão de array, o objeto excluído é o objeto array. Quando uma expressão de exclusão é executada, a função de desalocação selecionada deve ser chamada com o endereço do objeto excluído em uma expressão de exclusão de objeto único, ou o endereço do objeto excluído adequadamente ajustado para a sobrecarga de alocação de array (7.6.2.7) em uma expressão de exclusão de array, como seu primeiro argumento.

Desculpe, não entendo nada disso. Só tenho um pressentimento de que isso pode ser relevante.

Tenho um aplicativo que usa renderização atrasada da área de transferência para colar a hora atual. Mas: quando a hora for renderizada uma vez, sempre irá colar a mesma hora, e não a hora atualizada.

Acho que precisaria ligar SetClipboardData(CF_TEXT, nullptr);novamente, para restaurar outro caso de renderização atrasada, mas não sei quando ou onde devo fazer isso. Posso detectar quando o aplicativo de destino retirou os dados da área de transferência?

Como posso colar a hora atual cada vez que o usuário pressiona Ctrl+V?

#include <windows.h>
#include <thread>
#include <chrono>
#include <ctime>
#include <iomanip>
#include <sstream>

// Get current time with milliseconds (HH:MM:SS.xxx)
void GetTime(std::string& time_str)
{
    auto now = std::chrono::system_clock::now();
    auto in_time_t = std::chrono::system_clock::to_time_t(now);
    auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 1000;
    std::tm bt{};
    localtime_s(&bt, &in_time_t);
    std::ostringstream oss;
    oss << std::put_time(&bt, "%H:%M:%S") << '.' << std::setfill('0') << std::setw(3) << milliseconds.count();
    time_str = oss.str();
}

void RenderClipboardData(HWND hwnd) {
    std::string time_str;
    GetTime(time_str);

    EmptyClipboard();

    // Allocate global memory for the clipboard data
    HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, time_str.size() + 1);
    if (hGlobal) {
        // Lock the global memory and copy the string into it
        void* pGlobal = GlobalLock(hGlobal);
        if (pGlobal) {
            memcpy(pGlobal, time_str.c_str(), time_str.size() + 1);
            GlobalUnlock(hGlobal);
            SetClipboardData(CF_TEXT, hGlobal);
        }
        else
        {
            // Free the global memory if it wasn't successfully set
            GlobalFree(hGlobal); 
        }
    }
}

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {

    switch (uMsg) {
    case WM_RENDERFORMAT:
        if (wParam == CF_TEXT) {
            RenderClipboardData(hwnd);
        }
        break;
    case WM_CREATE:
         CreateWindow(
            L"STATIC",
            L"This application pastes the current time on Ctrl+V. ",
            WS_VISIBLE | WS_CHILD,
            10, 10, 600, 100,
            hwnd,
            nullptr,
            reinterpret_cast<LPCREATESTRUCT>(lParam)->hInstance,
            nullptr);

        if (OpenClipboard(hwnd)) {
            EmptyClipboard();
            SetClipboardData(CF_TEXT, nullptr); // Delayed rendering to get the current time
            CloseClipboard();
        }
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
    return 0;
}

int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow) {

    constexpr wchar_t CLASS_NAME[] = L"SampleWindowClass";

    WNDCLASS wc = {};
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.lpszClassName = CLASS_NAME;

    RegisterClass(&wc);

    HWND hwnd = CreateWindowEx(
        0,                              // Optional window styles.
        CLASS_NAME,                     // Window class
        L"Delayed Clipboard Rendering", // Window text
        WS_OVERLAPPEDWINDOW,            // Window style

        // Size and position
        CW_USEDEFAULT, CW_USEDEFAULT, 640, 120,

        nullptr,       // Parent window    
        nullptr,       // Menu
        hInstance,     // Instance handle
        nullptr        // Additional application data
    );

    if (hwnd == nullptr) {
        return 0;
    }

    ShowWindow(hwnd, nCmdShow);

    MSG msg = {};
    while (GetMessage(&msg, nullptr, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return 0;
}

Eu tentei:

• processar a WM_DESTROYCLIPBOARDmensagem e redefinir a área de transferência para renderização atrasada.

Eu estava lendo algum código .NET e encontrei o seguinte em DispatcherSynchronizationContext

/// 
///     Wait for a set of handles.
/// 
///  
///     Critical - Calls WaitForMultipleObjectsEx which has a SUC.
///  
[SecurityCritical] 
[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.ControlPolicy|SecurityPermissionFlag.ControlEvidence)]
public override int Wait(IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) 
{
    if(_dispatcher._disableProcessingCount > 0)
    {
        // Call into native code directly in order to avoid the default 
        // CLR locking behavior which pumps messages under contention.
        // Even though they try to pump only the COM messages, any 
        // messages that have been SENT to the window are also 
        // dispatched.  This can lead to unpredictable reentrancy.
        return MS.Win32.UnsafeNativeMethods.WaitForMultipleObjectsEx(waitHandles.Length, waitHandles, waitAll, millisecondsTimeout, false); 
    }
    else
    {
        return SynchronizationContext.WaitHelper(waitHandles, waitAll, millisecondsTimeout); 
    }
} 

O que significa "tem um SUC"?