All perguntas(coding)

Avisos do compilador geralmente fornecem dicas úteis para erros comuns de programação. Muitas vezes, recomenda-se transformar avisos do compilador em erros (por exemplo, aqui ). Na minha experiência, isso é útil para evitar que avisos sejam ignorados, especialmente em bases de código maiores ou em sistemas de compilação automatizados. No entanto, alguns avisos são úteis como avisos e não podem ser transformados em erros, seja porque podem ser falsos positivos ou porque a base de código não pode ser adaptada imediatamente, mas isso leva algum tempo de transição.

Como solução alternativa, eu poderia compilar o mesmo código duas vezes:

1. Uma execução com a maioria ou todos os avisos habilitados (por exemplo, -Wextra), mas sem transformá-los em erros (ou seja, sem -Werror)
2. Uma segunda execução com um conjunto menor de avisos, mas com configurações pedantes (ou seja, com a -Werroropção de linha de comando)

Dessa forma, o projeto de código se beneficiaria de mais avisos do que poderia corrigir atualmente.

Existe uma maneira de fazer isso diretamente, ou seja, com uma única etapa de compilação, não duas?

Li algumas menções à -Wno-error=[name]opção em outra pergunta e ela mal foi mencionada na referência de linha de comando mais recente do clang , mas não tenho detalhes. Caso eles forneçam uma solução para a minha pergunta, você poderia explicar melhor o que ela faz e/ou fornecer um link para onde está documentada?

Tentei corresponder a um genérico Result<&mut T, T>dentro de um const fn, mas o compilador não permitiu. Seria necessário remover o valor no final do escopo, o que atualmente não é possível dentro de um const fn.

Trunquei um pouco meu código e finalmente cheguei a este trecho. Ele continua dando o mesmo erro, pelo mesmo motivo, mas não é mais genérico.

struct Dummy;

impl Drop for Dummy {
    fn drop(&mut self) {
        println!("dropped");
    }
}

const fn const_match(result: Result<Dummy, ()>) -> Result<Dummy, ()> {
    match result { //^^^^^^ the destructor for this type cannot be evaluated in constant functions
        Ok(ok) => Ok(ok),
        Err(err) => Err(err),
    }
} // <- value is dropped here

O compilador me dá a seguinte mensagem de erro:

error[E0493]: destructor of `Result<Dummy, ()>` cannot be evaluated at compile-time
  --> <source>:9:22
   |
9  | const fn const_match(result: Result<Dummy, ()>) -> Result<Dummy, ()> {
   |                      ^^^^^^ the destructor for this type cannot be evaluated in constant functions
...
14 | }
   | - value is dropped here

Ao remover consttudo, a compilação fica perfeita, então criei um teste para verificar se o valor realmente é descartado dentro dessa função.

struct Dummy;

impl Drop for Dummy {
    fn drop(&mut self) {
        println!("dropped");
    }
}

fn const_match(result: Result<Dummy, ()>) -> Result<Dummy, ()> {
    match result {
        Ok(ok) => Ok(ok),
        Err(err) => Err(err),
    }
}

fn main() {
    let dummy = const_match(Ok(Dummy));
    let err = const_match(Err(()));

    std::mem::forget(dummy);
}

Aqui está o link do godbolt para um exemplo de código idêntico. Como esperado, ele não produz nenhuma saída, então o destruidor nunca é executado dentro de const_match.

Por que o destruidor precisa ser capaz de ser executado?

Estou tendo problemas com argumentos em programas de console C++ criados no C++Builder 12 Community Edition.

Se o executável estiver em uma pasta com espaços no nome, por exemplo, "test dir", e eu o invoco de uma sessão de console em uma pasta DIFERENTE, então os argumentos extraídos pelo meu código estão incorretos. Se o caminho do arquivo executável não tiver espaços, tudo funciona bem. Se eu executá-lo dentro do IDE, também está OK. O código criado no Visual Studio 22 também funciona OK.

CPPtest.cpp

#include <iostream.h>

int main(int argc, char* argv[])
{
    cout << "argc: " << argc << "\n"; 
    cout << "argv0: " << argv[0] << "\n"; 
    cout << "argv1: " << argv[1] ; 
    return 0 ;`
}

O executável está localizado em um diretório chamado "Misc projects", CWD é "C:\Junk":

C:\Junk>C:\"Misc projects"\CPPtest 3 8
argc: 2 ## INCORRECT: Should be 3
argv0: c:\Misc projects\CPPtest.exe
argv1: projects\CPPtest 3 8 # INCORRECT should be 8

Código idêntico quando executado dentro do Visual Studio 22 funciona corretamente.

import re

texto = "ABC ABC. ABC.png ABC thumb.png"

regex = r"ABC(?!.png)|ABC(?! thumb.png)"

novo = re.sub(regex, "bueno", texto)

print(novo)

Estou tentando substituir a palavra ABC por exceções. Só quero substituí-la se ela não vier depois da palavra ".png" ou "thumb.png". A string seria então "ABC thumb.png"

Eu esperava

bueno bueno. ABC.png ABC thumb.png

Mas a saída é esta

bueno bueno. bueno.png bueno thumb.png

Ele não detecta o espaço e, na verdade, bagunça a primeira condição.

Pergunta - veja Compiler Explorer

Se eu criar um std::vector<int>e inicializá-lo de duas maneiras, ambas chamarão o std::initializer_listconstrutor.

std::vector<int>  v1{1, 2, 3};     // Calls vector(initializer_list< int >)
std::vector<int>  v2 = {1, 2, 3};  // Calls vector(initializer_list< int >)

Mas se eu usar uma classe que converte implicitamente de int:

struct Imp { Imp(int) {} };

Então o segundo método de inicialização chama o construtor que recebe um par de iteradores.

std::vector<Imp>  v3{1, 2, 3};     // Calls vector(initializer_list< Imp >)
std::vector<Imp>  v4 = {1, 2, 3};  // Calls vector(const int*, const int* ) ???

Isso só acontece usando GCC 14.2 . Ao usar Clang 19.1 ou MSVC 19.40 , ambos v3e v4chamam o initializer_listconstrutor. O nível de otimização não faz diferença

Por que a = {}sintaxe chama vector(const int*, const int*)o GCC?

Investigação adicional

Tentei criar meu próprio modelo de classe que tem ambos os construtores:

template <typename T>
struct Custom {
    Custom(std::initializer_list<T>) {}
    Custom(const int*, const int*)   {}
};

Agora, tanto a sintaxe {}e = {}chamam o initializer_listconstrutor no GCC.

Custom<Imp>       v5{1, 2, 3};     // Calls Custom(initializer_list< Imp >)
Custom<Imp>       v6 = {1, 2, 3};  // Calls Custom(initializer_list< Imp >)

Onde as coisas ficam realmente confusas é se eu me especializo std::vectorpara meu tipo de conversão implícita Imp. Então há três casos:

Caso 1 - Fornecerinitializer_listapenas ctor

template <>
struct std::vector<Imp> {
    vector(initializer_list<Imp>)   {}
};

Resultado - Ambas as sintaxes chamam o ctor fornecido

std::vector<Imp> v7{1, 2, 3};      // Calls vector(initializer_list< Imp >)
std::vector<Imp> v8 = {1, 2, 3};   // Calls vector(initializer_list< Imp >)

Caso 2 - Fornecerconst int*apenas ctor

template <>
struct std::vector<Imp> {
    vector(const int*, const int*)   {}
};

Resultado - Ambas as sintaxes falham na compilação (nenhum ctor correspondente)

std::vector<Imp> v9{1, 2, 3};      // Error - no matching ctor
std::vector<Imp> vA = {1, 2, 3};   // Error - no matching ctor

Caso 3 - Forneça ambos os ctors

template <>
struct std::vector<Imp> {
    vector(initializer_list<Imp>)    {}
    vector(const int*, const int*)   {}
};

Resultado - A{}sintaxe chama oinitializer_listctor, enquanto a= {}sintaxe chama oconst int*ctor

std::vector<Imp> vB{1, 2, 3};      // Calls vector(initializer_list< Imp >)
std::vector<Imp> vC = {1, 2, 3};   // Calls vector(const int*, const int*) ???

É aqui que estou perdido.

No caso 3 , como fornecer o initializer_listconstrutor permite que o const int*construtor seja chamado?

EDITAR

Perguntaram como eu sei qual construtor está sendo chamado. Isso começou quando eu estava olhando quando os construtores copy vs. move são chamados. std::initializer_listnão pode ser movido de. Mas aqui estão alguns exemplos adicionais, com prints.

Exemplo 1 - Usando um tipo autônomo

struct Imp { Imp(int) {} };

template <typename T>
struct Custom {
    Custom(std::initializer_list<T>)    { std::printf("initializer_list<T>\n");    }
    Custom(const int*, const int*)      { std::printf("const int*, const int*\n"); }
};

int main(int argc, char *argv[]) {
    Custom<Imp>     v{1, 2, 3};
    Custom<Imp>     w = {1, 2, 3};

Impressões:

initializer_list<T>
initializer_list<T>

Exemplo 2 - Usando uma especialização std::vector

struct Imp { Imp(int) {} };

template <>
struct std::vector<Imp> {
    vector(initializer_list<Imp>)       { std::printf("initializer_list<T>\n");    }
    vector(const int*, const int*)      { std::printf("const int*, const int*\n"); }
};

int main(int argc, char *argv[]) {
    std::vector<Imp>    v{1, 2, 3};
    std::vector<Imp>    w = {1, 2, 3};

Impressões:

initializer_list<T>
const int*, const int*

A única diferença entre os dois exemplos é que um é uma especialização std:: e o outro não.

Por que isso mudaria qual sobrecarga de ctor é chamada?

Gostaria de identificar todas as linhas em um data frame (ou matriz) cujos valores nas colunas 1 e 2 correspondem a um par específico. Por exemplo, se eu tiver uma matriz

testmat=rbind(c(1,1),c(1,2),c(1,4),c(2,1),c(2,4),c(3,4),c(3,10))

Gostaria de identificar as linhas que contêm qualquer um dos seguintes pares, ou seja, todas as linhas que contêm uma combinação de 1,2 ou 2,4 em suas primeira e segunda colunas

of_interest = rbind(c(1,2),c(2,4))

O seguinte não funciona

which(testmat[,1] %in% of_interest[,1] & testmat[,2] %in% of_interest[,2])

porque, como esperado, ele retorna todas as combinações de 1,2 na primeira coluna e 2,4 na segunda (ou seja, linhas 2,3,5 em vez de apenas as linhas 2 e 5, como desejado), de modo que a linha [1,4] é incluída, mesmo que este não seja um dos pares que estou consultando. Deve haver alguma maneira simples de usar which...%in%... para corresponder a pares específicos como este, mas não consegui encontrar um exemplo disso que funcione.

Observe que preciso das posições/números de linhas que correspondem à condição desejada.

Hoje, enquanto trabalhava em um projeto para um curso de “Design Patterns” da faculdade (Java 11 necessário), descobri um problema com a restrição de acesso do modificador de acesso que pode ser ignorado declarando var. Eu sei como var é usado, é apenas um açúcar sintático que deixa a inferência de tipo para o compilador.

Não consigo descobrir que tipo de alias a var realmente é aqui:

• é "Child.InnerChild"? Isso não seria uma incompatibilidade de tipo?
• "InnerParent"? Isso não ignora o restritor de acesso protegido?

Aqui está meu código simplificado:

public abstract class Parent {
    protected abstract static class InnerParent {
        public InnerParent self() {
            return this;
        }
    }
}

public class Child extends Parent {
    public static class InnerChild extends InnerParent {}
}

import anotherpackage.Child;

/**
 * Compiling with Java 11:
 */
public class Main {
    public static void main(String[] args) {
        // As we expected a compilation error: The returned static type does not match the expected type
        // Child.InnerChild innerChild = new Child.InnerChild().self();

        // As we expected a compilation error: Parent.InnerParent is package visible (protected)
        // Parent.InnerParent innerChild = new Child.InnerChild().self();

        // Why does it compile and run correctly here?
        // var is just syntactic sugar for the compiler type, it should be a Parent.InnerParent alias here,
        // why is var allowed to transgress the protected access restriction?
        var innerChild = new Child.InnerChild().self(); // perhce' non da' errore ? var e' un alias di cosa ?
        System.out.println(innerChild);
        System.out.println(innerChild.getClass().getName());
    }
}

Também perguntei ao ChatGPT, mas ele não está respondendo tão bem quanto eu gostaria e não tenho certeza se está correto:

Por que varfunciona

• Tipo inferido : O tipo inferido para var innerChildé Parent.InnerParent.
• Regras de acesso : como o tipo é inferido e não escrito explicitamente no código, o compilador não impõe restrições de acesso para a variável declarada.

Encontrei um novo problema: por que não consigo acessar getClass()?

No entanto, é possível compilar dessa maneira.

System.out.println(((Object) innerChild).getClass().getName());
// OUTPUT: com.github.lorenzoyang.anotherpackage.Child$InnerChild

Um colega de trabalho me mostrou este programa:

#include <iostream>
#include <memory>

struct A {
    std::shared_ptr<int> u{ new int };
};

struct B : virtual A {};
struct C : virtual A {};
struct D : B, C {};

int main() {
    D d;
    d = D( d );
    std::cout << d.u;
}

que apesar de inicializar shared_ptrcom new intimprime zero. Demonstração online: https://gcc.godbolt.org/z/n3Kxbc3Pf

Vejo que isso está de alguma forma relacionado à herança de diamante e à classe base virtual comum.

O programa tem algum comportamento indefinido ou está bem formado e o padrão exige a impressão de zero aqui?

Tenho o seguinte repositório:

A--B--C--D--E--F--G--H--I--J
                   \
                    K--L--M
main -> J
DEV -> M

Quero compactar os commits entre B e E para que o repositório fique assim:

A--N--F--G--H--I--J
          \
           K--L--M
main -> J
DEV -> M

Tentei fazer um squash interativo, mas o melhor que consegui foi algo assim:

  N--F'-G'-H'-I'-J'
 /  
A--B--C--D--E--F--G--H--I--J
                   \
                    K--L--M
remote/main -> J
main -> J'
DEV -> M

então a ramificação DEV não está anexada onde deveria estar.

Qual é a maneira de fazer isso?

Para aqueles que desejam sinalizar isso como duplicado, esta pergunta não está relacionada a nenhuma das perguntas como:

Como calcular o tamanho da memória de um array Java?

Tamanho de memória de matrizes int[] do sistema Java de 32 bits

Em Java, quando uma matriz de primitivos inté criada:

int[] arr = new int[1000];

A JVM aloca memória para todo o comprimento do array * 4 bytes, ou seja, 4000 bytes após a declaração acima? Não vamos nos preocupar com overheads constantes como cabeçalhos etc.

Meu entendimento é que no caso de tipos numéricos primitivos, por exemplo int, doubleetc., o valor padrão '0' também é um valor válido, portanto precisa de memória. Na verdade, a memória necessária completa deve ser alocada no momento de tais declarações.

Como eu poderia verificar isso?