Raildex's questions

Estou usando clangd no meu projeto C++.

Quando clangd sugere uma função, ele também insere marcadores de posição para as funções:

No entanto, quando eu digito um construtor, eu só recebo a janela de sobrecarga que eu posso percorrer. RETURN criará apenas parênteses vazios:

Posso fazer com que o clangd insira espaços reservados para parâmetros do construtor?

Editar:

Meus argumentos clangd:

"clangd.arguments": [
    "--pretty",
    "--compile-commands-dir=${workspaceFolder}/build",
    "--background-index",
    "--completion-style=detailed",
    "--header-insertion=iwyu",
    "--function-arg-placeholders"
],

$ clangd --version
clangd version 19.1.7

Edição 2:

Os placeholders já estão lá, só preciso rolar para baixo para um construtor em particular. É um pouco inconveniente.

No momento tenho o seguinte código:

#include <iterator>
#include <vector>
struct bar{};
struct details {};
struct foo {
    details det;
    std::vector<bar> data;
};

template <std::input_iterator Iter>
foo create_foo(const details& details, Iter begin, Iter end) {
    return foo {
        .det = details,
        .data = {begin, end}
    };
}

int main() {

    std::vector<bar> bars = {bar{},bar{},bar{}};
    create_foo({}, bars.begin(), bars.end());
    return 0;
}

Demonstração do Godbolt

foo::dataé um Container para bars. Seu construtor recebe dois Iteradores.

Quero restringir os iteradores de entrada para serem iteradores de contêineres contendo barapenas, por exemplo, um std::vector<bar>::iteratorou umstd::list<bar>::iterator

Como eu conseguiria isso com conceitos?

Estou usando uma API que espera um bloco contíguo de memória que contém ponteiros. Os próprios ponteiros podem ser nullptr.

Atualmente, uso C-Arrays:

ID3D11ShaderResourceView* srvs[] = {
    room_diffuse_srv.Get(),
    lightmap_srv.Get(),
    room_normal_srv.Get(),
    nullptr,
    nullptr,
    nullptr,
    nullptr,
    nullptr,
    nullptr,
    input.ambient_occlusion,
    reflection_srv.Get(),
    reflection_extents_srv.Get(),
    nullptr,
    nullptr,
    nullptr
};
ctx->VSSetShaderResources(0, UINT(std::size(srvs)), std::data(srvs));

Minha cadeia de ferramentas contém clang-tidy, que recomenda evitar matrizes C e preferir std::array.

std::arraytem um guia de dedução que me permite inicializar uma matriz como esta:

std::array srvs = {
    room_diffuse_srv.Get(),
    lightmap_srv.Get(),
    room_normal_srv.Get(),
    nullptr,
    nullptr,
    nullptr,
    nullptr,
    nullptr,
    nullptr,
    input.ambient_occlusion,
    reflection_srv.Get(),
    reflection_extents_srv.Get(),
    nullptr,
    nullptr,
    nullptr
};

Isso só funciona quando o primeiro elemento e todos os elementos seguintes são implicitamente conversíveis para o mesmo tipo (ponteiro), neste caso ID3D11ShaderResourceView*.

Ele se desfaz assim que o primeiro elemento contém um nullptr:

std::array srvs = {
    nullptr,
    lightmap_srv.Get(), // error: "a value of type "ID3D11SamplerState *" cannot be used to initialize an entity of type "std::_Enforce_same<std::nullptr_t, std::nullptr_t, ID3D11SamplerState *, std::nullptr_t, std::nullptr_t, ID3D11SamplerState *>::type" (aka "std::nullptr_t")"
    room_normal_srv.Get(),
    nullptr,
    nullptr,
    nullptr,
    nullptr,
    nullptr,
    nullptr,
    input.ambient_occlusion,
    reflection_srv.Get(),
    reflection_extents_srv.Get(),
    nullptr,
    nullptr,
    nullptr
};

faz sentido, porque o primeiro elemento tem o tipo std::nullptr_t.

Posso inicializar/deduzir um std::arraysem especificar o tipo explicitamente e permitir que o primeiro elemento seja nullptr? Eu poderia converter o primeiro nullptrelemento ( ), mas então eu poderia apenas escrevê-lo no tipo também.

O C11 adicionou novas funções de verificação de limites à biblioteca padrão, como getenv_s.

Porém, quando incluo <cstdlib>, não tenho std::getenv_s, apenas getenv_s(namespace global).

cppreference tem a seguinte nota:

Assim como todas as funções com verificação de limites, getenv_s só tem garantia de estar disponível se __STDC_LIB_EXT1__for definido pela implementação e se o usuário definir __STDC_WANT_LIB_EXT1__a constante inteira 1 antes de incluir <stdlib.h>.

Mesmo quando defino __STDC_WANT_LIB_EXT1__como 1, meu compilador (MSVC C++23) não encontra a std::getenv_sfunção.

Não <cstdlib>deveria trazer todos os símbolos de <stdlib.h>para o stdnamespace?

Eu queria "voltar ao básico" e tentar escrever uma implementação de vetor C. Ele está usando void* para armazenar os dados e tento imitar um pouco a parte do contador C++.

Estou tendo dificuldade em apagar elementos. precisamente o tamanho do vetor não parece corresponder ao esperado após apagar vários elementos.

Aqui está a implementação da função apagar:

typedef void* vector_iterator;

vector_iterator vector_begin(vector* vec) {
    return vec->data;
}

vector_iterator vector_end(vector* vec) {
    return ((unsigned char*)vec->data) + ((vec->element_size * (vec->size+1))); // "past the last element"
}

void vector_erase(vector* vec, vector_iterator iterator) {
    assert(iterator >= vector_begin(vec));
    assert(iterator < vector_end(vec));
    assert(((uintptr_t)iterator - (uintptr_t)vector_begin(vec)) % vec->element_size == 0);
    unsigned char* dest = (unsigned char*)iterator;
    unsigned char* src = dest + vec->element_size; // src is the element erased element + 1, since we want to pull all objects forward
    size_t bytes_to_copy= (unsigned char*)vector_end(vec) - (unsigned char*)src - vec->element_size;
    memcpy(dest, src, bytes_to_copy); // copy all elements from (iterator +1) forward
    vec->size--;
}

vector_iterator vector_iterator_offset(vector_iterator iterator,vector* vec, ptrdiff_t offset) {
    return (unsigned char*)iterator + (vec->element_size * offset);
}

O uso de apagar é usado assim.

vector_erase(vec, vector_iterator_offset(vector_begin(vec),vec,2)); // erase the second element

Quando apago 3 elementos, o tamanho relatado do vetor está correto, mas meu loop imprime tamanho+1 elementos.

    vector* vec = vector_create_capacity(sizeof(char), 10);
    //test for push back
    for(char i = 'A'; i < 'A'+10; ++i) {
        vector_push_back(vec, &i);
    }
    
    //...//
    
    fprintf(stdout, "Size: %zu\n",vector_size(vec));
    fflush(stdout);

    vector_erase(vec, vector_iterator_offset(vector_begin(vec),vec,2)); // erase 'C'
    fprintf(stdout, "Size: %zu\n",vector_size(vec));
    fflush(stdout);

    vector_erase(vec, vector_iterator_offset(vector_begin(vec),vec,2)); // erase 'D'
    fprintf(stdout, "Size: %zu\n",vector_size(vec));
    fflush(stdout);

    vector_erase(vec, vector_iterator_offset(vector_begin(vec),vec,2)); // erase 'E'
    fprintf(stdout, "Size: %zu\n",vector_size(vec));
    fflush(stdout);
    
    it = vector_begin(vec);
    for(;it != vector_end(vec); (it = vector_iterator_offset(it, vec, 1))) {
        
        char data = *(char*)it;
        fprintf(stdout,"%c\n", data);
        fflush(stdout);
    }
    fprintf(stdout,"%zu",vector_size(vec));
    fflush(stdout);
    //8 printed letters instead of 7 with double 'J'?
    vector_destroy(vec);

A saída no final é

A
B
F
G
H
I
J
J

Demonstração Godbolt, porque o código é muito longo

meu vector_end(vec) está incorreto ou o apagamento está incorreto?

Eu tenho um UserControl que é usado como "modelo" para caixas de diálogo de janela. Ele contém um botão Fechar e um botão Cancelar.

<UserControl x:Class="TombLib.WPF.Controls.WindowControlButtons"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:TombLib.WPF.Controls"
             mc:Ignorable="d"
             xmlns:darkUI="clr-namespace:DarkUI.WPF;assembly=DarkUI.WPF"
             xmlns:vm="clr-namespace:TombLib.WPF.ViewModels"
             xmlns:sg="clr-namespace:SpacedGridControl;assembly=SpacedGridControl"
             d:DesignHeight="100" d:DesignWidth="300"
             x:Name="root">
    <StackPanel VerticalAlignment="Center" HorizontalAlignment="Right" Height="Auto" Orientation="Horizontal">
        <Button Name="oKButton" Margin="{x:Static darkUI:Defaults.MediumThickness}" Width="100" Height="Auto" Command="{Binding Close}" CommandParameter="{Binding Window}" Content="OK"></Button>
        <Button Name="cancelButton" Margin="{x:Static darkUI:Defaults.MediumThickness}" Width="100" Height="Auto" Command="{Binding Path=Cancel}" CommandParameter="{Binding Window}" Content="Cancel"></Button>
    </StackPanel>
</UserControl>

public partial class WindowControlButtons : UserControl
{
    public static readonly DependencyProperty CancelProperty =
        DependencyProperty.Register(
        nameof(Cancel),
        typeof(ICommand),
        typeof(WindowControlButtons),
        new PropertyMetadata(null));
    public ICommand Cancel
    {
        get { return (ICommand)GetValue(CancelProperty); }
        set { SetValue(CancelProperty, value); }
    }

    public static readonly DependencyProperty CloseProperty =
        DependencyProperty.Register(
        nameof(Close),
        typeof(ICommand),
        typeof(WindowControlButtons),
        new PropertyMetadata(null));
    public ICommand Close
    {
        get { return (ICommand)GetValue(CloseProperty); }
        set { SetValue(CloseProperty, value); }
    }

    public static readonly DependencyProperty WindowParameter =
        DependencyProperty.Register(
        nameof(Window),
        typeof(object),
        typeof(WindowControlButtons),
        new PropertyMetadata(null));
    public object? Window
    {
        get { return GetValue(WindowParameter); }
        set { SetValue(WindowParameter, value); }
    }


    public WindowControlButtons()
    {
        InitializeComponent();
    }
}

Quero usá-lo na seguinte janela:

<Window x:Class="TombLib.WPF.Windows.SelectIdWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:TombLib.WPF.Windows"
        mc:Ignorable="d"
        xmlns:ctrl="clr-namespace:TombLib.WPF.Controls"
        xmlns:vm="clr-namespace:TombLib.WPF.ViewModels"
        xmlns:sg="clr-namespace:SpacedGridControl;assembly=SpacedGridControl"
        xmlns:darkUI="clr-namespace:DarkUI.WPF;assembly=DarkUI.WPF"
        Title="SelectIdWindow" Height="100" Width="300"
        d:DataContext="{d:DesignInstance Type=vm:SelectIdViewModel }"
        x:Name="Self">
    <sg:SpacedGrid Margin="{x:Static darkUI:Defaults.MediumThickness}">
        <!-- REDACTED -->
        <ctrl:WindowControlButtons DataContext="{Binding ElementName=Self}" Window="{Binding ElementName=Self, Mode=OneWay}" Close="{Binding CloseCommand,Mode=OneWay}" Cancel="{Binding CancelCommand,Mode=OneWay}" Height="Auto" Width="Auto" Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" HorizontalAlignment="Right"/>
    </sg:SpacedGrid>
</Window>

public partial class SelectIdWindow : Window
{
    public ICommand? CloseCommand { get; set; }
    public ICommand? CancelCommand { get; set; }
    public SelectIdWindow()
    {
        CloseCommand = new WindowCloseCommand();
        InitializeComponent();
    }
}

public class SelectIdViewModel
{
    public string RequestedId { get; set; } = string.Empty;
    public IEnumerable<string> TakenIds { get; set;}
    public SelectIdViewModel(IEnumerable<string> takenIDs) {
        TakenIds = takenIDs;
    }
}

Porém, quando abro a janela da seguinte maneira:

SelectIdWindow w = new SelectIdWindow();
var takenIDs = Entities.Select(kv => kv.Key.Name);
w.DataContext = new SelectIdViewModel(takenIDs);
w.ShowDialog();

Recebo os seguintes erros durante a vinculação de WindowControlButtons:

É DataContextexplicitamente definido Selfcomo deve representar a janela, não o ViewModel. O que estou fazendo de errado aqui?