All perguntas(coding)

Estou escrevendo uma ferramenta simples em Qt 6.8 C++23 para aprender sobre Qt. Ubuntu 22.04 VS Code.

Tenho 2 QLineEdit para diretório de origem e diretório de destino. Quando o usuário foca na edição de linha, a ferramenta deve abrir o QFileDialog para que ele não precise digitar o caminho completo. A edição de linha em si deve ser somente leitura.

A fonte para o diálogo contido pode ser encontrada no GitHub .

O problema é que quando a caixa de diálogo do arquivo fecha, ela reabre imediatamente porque o foco ainda está na linha de edição. Como faço para perder o foco depois que a caixa de diálogo do arquivo fecha?

#ifndef DIRECTORYLINEEDIT_H_
#define DIRECTORYLINEEDIT_H_

#include <QLineEdit>
#include <QFileDialog>
class DirectoryLineEdit : public QLineEdit {
    Q_OBJECT

public:
    explicit DirectoryLineEdit(const char* dleName, const char* title, int leWidth, QWidget *parent = nullptr)
    : QLineEdit{parent}, fileDialogTitle{title}
    {
        setObjectName(QString::fromUtf8(dleName));
        setStyleSheet("width: " + QString::number(leWidth) + "px;");
        setReadOnly(true);
    }

    void focusInEvent(QFocusEvent *event)
    {
        QString textToChange = text();
    
        textToChange = QFileDialog::getExistingDirectory(nullptr, fileDialogTitle,
            textToChange, QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
    
        setText(textToChange);    
    }
    

private:
    QString fileDialogTitle;
};

#endif // DIRECTORYLINEEDIT_H_

Que tipo de expressão polar ( pl.Expr) pode ser usada em um contexto de filtro que corresponderá a qualquer coisa, incluindo nulos?

Caso de uso: Funções auxiliares e de dicas de tipo que devem retornar um polars.Expr.

Às vezes, escrevo funções que envolvem renomear/reetiquetar muitas variáveis ​​em lugares diferentes, usando um reetiquetador. O reetiquetador é usado em vários contextos, tanto diretamente no meu código (por exemplo, para títulos) quanto passado para outras funções (por exemplo, facet_wrap). Isso é bom para usos típicos:

library(ggplot2)
library(dplyr)

plotfcn <- function(df, x, y, facet, fancy_labs){
  # Strings of x & y (for axis titles)
  xStr <- fancy_labs(deparse(substitute(x)))
  yStr <- fancy_labs(deparse(substitute(y)))
  
  #base plot
  p <- ggplot(df, aes({{x}}, {{y}})) + 
    geom_point()
  
  #add facets (with labels) and axis labels
  p + facet_wrap(vars({{facet}}), labeller=fancy_labs) +
    labs(x=xStr, y=yStr)
}

mylabs <- as_labeller(c(
  'compact' = 'Small Family Car',
  'midsize' = 'Medium Family Car',
  'minivan' = 'For the Kids',
  'pickup' = 'For the Stuff',
  'displ' = 'Engine Displacement (L)',
  'hwy' = 'Highway Mileage (mpg)'))

classlist <- c('compact', 'midsize', 'minivan', 'pickup')

mpg_lim <- mpg %>% filter(class %in% classlist) 

mpg_lim %>% plotfcn(displ, hwy, class, fancy_labs = mylabs)

Agora eu gostaria de tornar o argumento labeller opcional. Envolver qualquer coisa que envolva rótulos em uma instrução if/else é fácil:

plotfcn <- function(df, x, y, facet, fancy_labs=NULL){
  # Strings of x & y (for axis titles)
  if(!is.null(fancy_labs)) {
    xStr <- fancy_labs(deparse(substitute(x)))
    yStr <- fancy_labs(deparse(substitute(y)))
  } 
  
  #base plot
  p <- ggplot(df, aes({{x}}, {{y}})) + 
    geom_point() 
  
  #optional: add labels using labeller
  if(!is.null(fancy_labs)) { 
    p + 
      facet_wrap(vars({{facet}}), labeller=fancy_labs) +
      labs(x=xStr, y=yStr)
    } else { 
      p + facet_wrap(vars({{facet}}))  
    }
}

mpg_lim %>% plotfcn(displ, hwy, class, fancy_labs = mylabs)

mpg_lim %>% plotfcn(displ, hwy, class)

No entanto, se possível, gostaria de evitar colocar o argumento facet_wrap() na instrução if/else. (No meu código real, ele já está em uma sequência if/else, então adicionar este if/else adicional adicionará muitas ramificações e copiar/colar repetidamente, o que é trabalhoso de trabalhar.) Esta resposta sugere usar uma construção ellipse para passar o argumento labeller para facet_wrap, o que funciona muito bem - exceto que não consigo descobrir como chamar a mesma função labeller para os rótulos do eixo. Eu precisaria passar o mesmo argumento no meu código duas vezes com dois nomes diferentes, como mostrado abaixo, ou há alguma maneira de chamar o argumento labeller por meio da construção ellipses e independentemente no meu código?

plotfcn <- function(df, x, y, facet, fancy_labs=NULL, ...){
  # Strings of x & y (for axis titles)
  if(!is.null(fancy_labs)) {
    xStr <- fancy_labs(deparse(substitute(x)))
    yStr <- fancy_labs(deparse(substitute(y)))
  } 
  
  #base plot - calls labeller using ...
  p <- ggplot(df, aes({{x}}, {{y}})) + 
    geom_point() +
    facet_wrap(vars({{facet}}), ...)
  
  #optional: add labels using labeller
  if(!is.null(fancy_labs)) { 
    p + labs(x=xStr, y=yStr)
    } else { 
      p
    }
}

#this works, but involves calling the same parameter (mylabs) twice under two different names, which is annoying
mpg_lim %>% plotfcn(displ, hwy, class, fancy_labs = mylabs, labeller=mylabs)
mpg_lim %>% plotfcn(displ, hwy, class)

Se eu configurar a função com um argumento labeller function(df, x, y, facet, labeller = NULL, ...), a construção ellipsis não dispara, e minhas facetas não são rotuladas. Mas se eu configurá-la apenas com as ellipses function(df, x, y, facet, ...), não posso verificar sua presença usando is.null()ou missing()para disparar minhas instruções if . Existe alguma maneira de fazer com que as instruções if reconheçam a presença/ausência do argumento labeller?

Como faço o seguinte produto escalar em 3 dimensões com numpy?

Tentei:

x = np.array([[[-1, 2, -4]], [[-1, 2, -4]]])
W = np.array([[[2, -4, 3], [-3, -4, 3]], 
              [[2, -4, 3], [-3, -4, 3]]])
y = np.dot(W, x.transpose())

mas recebi esta mensagem de erro:

    y = np.dot(W, x)
ValueError: shapes (2,2,3) and (2,1,3) not aligned: 3 (dim 2) != 1 (dim 1)

Seu equivalente em 2 dimensões é:

x = np.array([-1, 2, -4])
W = np.array([[2, -4, 3],
              [-3, -4, 3]])
y = np.dot(W,x)
print(f'{y=}')

que retornará:

y=array([-22, -17])

Além disso, y = np.dot(W,x.transpose())retornará a mesma resposta.

fn dangle() {
    fn get_str<'a>(s: *const String) -> &'a str {
        unsafe { &*s }
    }
    
    let s = String::from("hello");
    let dangling = get_str(&s);
    drop(s);
    println!("Invalid str: {}", dangling);
}

#[test]
fn test() {
    dangle();  // it should panic, but does not
}

fn main() {
    dangle();  // panics
}

A main()função entra em pânico, como eu esperava. Mas por que a test()função roda com sucesso?

Tenho uma função personalizada que recebe como entrada um quadro de dados e, em seguida, uma seleção de colunas desse quadro de dados, assim:

library(dplyr)
df <- data.frame(x = c(1, 2, 3, 4, 5), y = c(11, 12, 13, 14, 15))

sample_fun <- function(df, x, y) {
  df <- df %>% 
    mutate(z = {{x}} * {{y}})
  }

df_out <- sample_fun(df, x, y)

Gostaria de tornar uma das colunas do data frame opcional e, então, fazer a função testar sua presença usando !if.null(). Se isso fosse um objeto, em vez de uma coluna do data frame, eu faria isso:

sample_fun <- function(df, x, y = NULL) {
  if(!is.null(y)) {
    df <- df %>% 
      mutate(z = {{x}} * y)
  }
  else(df <- df %>%
         mutate(z = {{x}}))
}

df_out <- sample_fun(df, x) 
df_out2 <- sample_fun(df, x, y)

No entanto, não consigo descobrir como verificar a presença da coluna de dados. Ambos if(!is.null(y))e if(!is.null({{y}}))retornam Error: object 'y' not found. Qual é a melhor maneira de verificar a presença de y, quando y é uma coluna de data frame em vez de um objeto independente?

Então, estou aprendendo C depois de anos de C# e imaginei que um bom projeto inicial seria algo um pouco mais simples.

Estou tentando invocar uma MessageBox em um aplicativo WPF em branco e parece que tudo funcionaria, mas por algum motivo não estou obtendo uma MessageBox.

Tanto o WpfApp quanto o aplicativo que criei são compilados em versões x64, então não vejo por que haveria problemas de arquitetura.

A saída de depuração também parece boa.

Tentei executar ambos os aplicativos com privilégios de administrador. Tentei invocar em diferentes aplicativos, como o Notepad (versão de 32 e 64 bits), assim como a Calculadora.

Process ID for WpfApp1.exe found: 948
Target process found. PID: 948
Opened handle to process.
Handle to user32.dll loaded successfully.
Address of MessageBoxA: 00007ffc67fc8b70
Allocated memory at remote address: 00000262a8500000
Successfully wrote message to remote memory.
Remote thread created successfully.
Remote thread completed.

Mas acho que há algo errado aqui?

#include <stdio.h>
#include <windows.h>
#include <tlhelp32.h>
#include <unistd.h>

DWORD GetPID(const char *processName);

int main(void) {
    DWORD processId = GetPID("WpfApp1.exe");

    if (!processId) {
        printf("Process not found\n");
        fflush(stdout);
        return 1;
    }
    printf("Target process found. PID: %lu\n", processId);
    fflush(stdout);

    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
    if (!hProcess) {
        printf("Failed to open process. Error code: %lu\n", GetLastError());
        fflush(stdout);
        return 1;
    }
    printf("Opened handle to process.\n");
    fflush(stdout);

    // Explicitly load user32.dll
    HMODULE hUser32 = LoadLibrary("user32.dll");
    if (!hUser32) {
        printf("Failed to load user32.dll. Error code: %lu\n", GetLastError());
        fflush(stdout);
        CloseHandle(hProcess);
        return 1;
    }
    printf("Handle to user32.dll loaded successfully.\n");
    fflush(stdout);

    LPVOID msgBoxAddress = (LPVOID)GetProcAddress(hUser32, "MessageBoxA");
    if (!msgBoxAddress) {
        printf("Failed to find address of MessageBoxA. Error code: %lu\n", GetLastError());
        fflush(stdout);
        FreeLibrary(hUser32);
        CloseHandle(hProcess);
        return 1;
    }
    printf("Address of MessageBoxA: %p\n", msgBoxAddress);
    fflush(stdout);

    LPVOID remoteString = VirtualAllocEx(hProcess, NULL, 256, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (!remoteString) {
        printf("Failed to allocate memory in target process. Error code: %lu\n", GetLastError());
        fflush(stdout);
        FreeLibrary(hUser32);
        CloseHandle(hProcess);
        return 1;
    }
    printf("Allocated memory at remote address: %p\n", remoteString);
    fflush(stdout);

    if (!WriteProcessMemory(hProcess, remoteString, "Hello World!", 13, NULL)) {
        printf("Failed to write to remote memory. Error code: %lu\n", GetLastError());
        fflush(stdout);
        VirtualFreeEx(hProcess, remoteString, 0, MEM_RELEASE);
        FreeLibrary(hUser32);
        CloseHandle(hProcess);
        return 1;
    }
    printf("Successfully wrote message to remote memory.\n");
    fflush(stdout);

    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)msgBoxAddress, remoteString, 0, NULL);
    if (!hThread) {
        printf("Failed to create remote thread. Error code: %lu\n", GetLastError());
        fflush(stdout);
        VirtualFreeEx(hProcess, remoteString, 0, MEM_RELEASE);
        FreeLibrary(hUser32);
        CloseHandle(hProcess);
        return 1;
    }
    printf("Remote thread created successfully.\n");
    fflush(stdout);

    WaitForSingleObject(hThread, INFINITE);
    printf("Remote thread completed.\n");
    fflush(stdout);

    VirtualFreeEx(hProcess, remoteString, 0, MEM_RELEASE);
    FreeLibrary(hUser32);
    CloseHandle(hThread);
    CloseHandle(hProcess);
    return 0;
}

DWORD GetPID(const char *processName) {
    PROCESSENTRY32 processEntry;
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (hSnapshot == INVALID_HANDLE_VALUE) {
        printf("Failed to create snapshot. Error code: %lu\n", GetLastError());
        fflush(stdout);
        return 0;
    }

    processEntry.dwSize = sizeof(processEntry);
    if (Process32First(hSnapshot, &processEntry)) {
        do {
            if (strcmp(processEntry.szExeFile, processName) == 0) {
                DWORD pid = processEntry.th32ProcessID;
                CloseHandle(hSnapshot);
                printf("Process ID for %s found: %lu\n", processName, pid);
                fflush(stdout);
                return pid;
            }
        } while (Process32Next(hSnapshot, &processEntry));
    }

    printf("Failed to find process: %s\n", processName);
    fflush(stdout);
    CloseHandle(hSnapshot);
    return 0;
}

Isso também parece bastante código comparado a vários artigos que li online.

Há UB no código abaixo?

#include <iostream>

int* p_n;

class A
{
public:

    A(int val) : n(val)
    {
        // At this point the compiler does not know if the object is const or not.
        p_n = &n;
    }

    int n;
};

int main()
{
    // A::n is const, because A is const, right?
    const A a(1);

    // but we change a const value here
    *p_n = 2;

    std::cout << a.n << std::endl;

    return 0;
}

Existe alguma diferença entre atribuir *p_ne fazer isso?

const_cast<A&>(a).n = 2;

EDITAR

Daqui :​

const e semântica volátil (7.1.6.1) não são aplicadas em um objeto em construção. Elas entram em vigor quando o construtor para o objeto mais derivado (1.8) termina.

Enquanto o objeto aestá em construção, ele não é conste a.nnão é const, mas eles se tornam constquando o construtor termina.

Então, p_naponta para o constobjeto ou não?

Estou adicionando muitos marcadores em um mapa do Google no Jetpack Compose, e funciona, mas preciso pintá-los apenas quando o nível de zoom estiver acima de 15, então adicionei if (cameraPositionState.position.zoom > 15)antes de adicionar os marcadores. Também funciona, mas funciona muito lento porque cada vez que movo a posição da câmera com o dedo, o mapa recompõe tudo e adiciona novamente todos os marcadores.

Como posso evitar essa recomposição toda vez que a câmera for movida?

Se eu remover isso, if (cameraPositionState.position.zoom > 15)as recomposições desaparecem e o mapa fica suave novamente, mas preciso dessa verificação para evitar pintar os criadores se o nível de zoom estiver acima de 15.

Como resolver isso?

val cameraPositionState = rememberCameraPositionState {
    position = CameraPosition.fromLatLngZoom(city, 13f)
}

GoogleMap(modifier = Modifier.fillMaxSize(), cameraPositionState = cameraPositionState) {
    if (cameraPositionState.position.zoom > 15) { // THIS LINE IS THE ISSUE
        val bitmapDescriptor = BitmapDescriptorFactory.fromResource(R.drawable.ic_bus_mini)
        for (busStop in uiState.data) {
            Marker(
                state = rememberMarkerState(position = LatLng(busStop.lat, busStop.lon)),
                title = busStop.name, icon = bitmapDescriptor,
            )
        }
    }
}

Tentei uma solução usando derivedstateof:

val showMarkers by remember(cameraPositionState.position.zoom) {
    derivedStateOf {
        cameraPositionState.position.zoom > 15
    }
}

e mudando o if por if (showMarkers) {mas o problema persiste, movendo a câmera, faz tudo recompor adicionando todos os marcadores novamente e atrasando o mapa

Gostaria de ter um conceito que verifica se um tipo é um contêiner de comprimento fixo. O tipo pode ser um array estilo C, um std::array, a std::spanou um contêiner personalizado. Posso verificar a condição do contêiner conforme mostrado no código abaixo, mas não consigo fazer com que ele verifique a condição de comprimento.

template <typename T, size_t N>
concept fixed_container =
   requires (T const& t)
   {
       {std::size(t)} -> std::same_as<size_t>;
       {std::begin(t)};
       {std::end(t)};
   }
   // && std::declval<T>().size() == N // Error: 'declval() must not be used!'
   // && T::size() == N // Error: 'call to non-static member function without an object argument'
   ;

// These should all be correct
static_assert( fixed_container<std::array<double, 3>, 3>);
static_assert(!fixed_container<std::array<double, 3>, 4>);
static_assert( fixed_container<std::span<double, 3>,  3>);
static_assert(!fixed_container<std::span<double, 3>,  4>);
static_assert( fixed_container<double[3],             3>);
static_assert(!fixed_container<double[3],             4>);

Alguma ideia?

EDIT: O bloco

   requires (T const& t)
   {
       {std::size(t)} -> std::same_as<size_t>;
       {std::begin(t)};
       {std::end(t)};
   }

pode ser substituído por uma única linha

   std::ranges::sized_range<T>