A indexação de pacotes foi introduzida no C++ 26 e eu esperava que esse recurso tivesse um impacto significativo nas coisas de metaprogramação, especialmente para indexação de pacotes que, de outra forma, exigiriam soluções alternativas.

Como a sintaxe do especificador de indexação de pacotes é:

typedef-name ... [ expression ] 

• onde typedef-nameestá identifierousimple-template-id

Com as informações acima, permite ter como:

template <typename>
using apply_t = bool;

// #1
template <typename... Args>
using A = apply_t<Args>...[0];
// can be reworked with: apply_t<Args...[0]>

// #2
template <template <typename...> typename... Temps>
using B = Temps<>...[0]
// no other way other than this because 'Temps...[0]<>' is not allowed yet (?)

Me deparei com o seguinte cenário:

fn compute_values(value: &mut String) {
    // the first computation should always work:
    let computed_value = String::from("computed value");
    // override the default String with the computed value:
    *value = computed_value;
    // some more code that returns a Result with values or an error message
}

fn main() {
    let mut value = String::from("default value");
    compute_values(&mut value);
    println!("value: {value}")
}

Este código é compilado com my rustc 1.74.1 (a28077b28 2023-12-04)e gera value: computed valuecomo eu esperava, mas a questão é: se esse código vazar memória.

Pelo que entendi, ele *value = computed_value;entra e não está mais disponível (o compilador Rust confirma isso, não posso depois) e não é desalocado quando o escopo da função termina. Como esta linha está efetivamente atribuindo a a a , suponho que todos os campos da estrutura sejam copiados para o local da estrutura original. Mas uma vez que a referência contida original é substituída, não há como desalocar a memória heap original que o antigo apontava. Como não estou usando nenhum Rust inseguro e o Rust parece ser seguro para a memória, só posso imaginar que a memória original seja desalocada automaticamente antes que a atribuição aconteça, mas não consegui encontrar nenhuma informação sobre esse tópico.computed_value*valueprintln!("{computed_value}");struct Stringstruct String&str&str

Encontrei os seguintes artigos que não responderam à minha pergunta:

• Existe uma maneira de atualizar uma string enferrujada?
• Como posso trocar um novo valor por um campo em uma referência mutável a uma estrutura?
• Como posso substituir todos os campos em uma referência mutável usando outra estrutura?

As respostas nomeadas std::mem::takee std::mem::swapque std::mem::replaceme levam a crer que o uso de uma delas é necessário neste caso.

Também verifiquei a documentação oficial sobre ferrugem, mas não encontrei nada.

Minhas perguntas são:

1. Este código está vazando memória?
2. O Rust não inseguro deveria ser seguro para a memória, mesmo ao substituir valores de referências mutáveis?
3. Existe alguma documentação (oficial) sobre a atribuição de desreferência?

PS: Teoricamente, o Rust pode otimizar let mut value = String::from("default value");de forma que String valueaponte para a constante da string e não para um local no heap. Isso não tornaria necessário desalocar a memória. Mas a coisa toda também funciona quando você lê a valuefrom stdin e a coisa toda deve ser necessariamente colocada na pilha.

Responder

Depois de ler a resposta de @cyqsimon (que é ótima, aliás), entendi que essa pergunta realmente não tem nada a ver com referências e, em vez disso, trata de descartar valores quando eles são substituídos. Armado com esse novo insight, encontrei este artigo do Rustonomicon que responde totalmente à minha pergunta e também fala sobre o que acontece quando as variáveis ​​são apenas inicializadas e, portanto, descartadas sob certas condições.

Eu escrevi o código:

        int x = 18;
        x *= 0.90; 
        System.out.println(x);

Este código impresso16

Contudo, quando escrevi

        int x = 18;
        x = x * 0.90; 
        System.out.println(x);

me deu o seguinte erro:incompatible types: possible lossy conversion from double to int

Eu esperava que ambos os exemplos de código resultassem exatamente no mesmo erro que x *= y;é igual a x = x * y;, mas x *= 0.90;de alguma forma funciona e x = x * 0.90;não funciona. Por que isso acontece?

A std::cell::Refestrutura em Rust é definida da seguinte forma:

pub struct Ref<'b, T: ?Sized + 'b> {
    // NB: we use a pointer instead of `&'b T` to avoid `noalias` violations, because a
    // `Ref` argument doesn't hold immutability for its whole scope, only until it drops.
    // `NonNull` is also covariant over `T`, just like we would have with `&T`.
    value: NonNull<T>,
    borrow: BorrowRef<'b>,
}

O // NBcomentário (presumo Nota bene / Nasty Bug ou algo assim?) implica que a seguinte definição não funcionaria, porque seria uma noaliasviolação (eles se referem aos atributos LLVM no backend?):

pub struct Ref2<'b, T: ?Sized + 'b> {
    value: &'b T,
    borrow: BorrowRef<'b>,
}

Não entendo esse ponto, pois tive a impressão de que a semântica não lexical do tempo de vida foi devidamente preservada na geração de código. Caso contrário, o seguinte exemplo simples (que obviamente compila) também seria ilegal, certo?:

struct Foo<'a> {
    v: &'a i32,
}
fn foo(x: &mut i32) {
    let f = Foo { v: x };
    *x = 5; // value modified while the `noalias` f.v pointer is still in scope
}

Alguém com mais conhecimento sobre os internos poderia me esclarecer sobre isso? Temo estar entendendo mal algo crítico aqui, levando a possíveis problemas em meu próprio código inseguro.

Como escolher o tipo de argumento de uma função membro do modelo de classe dependendo do valor do parâmetro do modelo de classe?

Aqui está um exemplo:

#include <memory>
template <class T, bool plainPointer=true>
class C
{
    // pseudocode below
    void f(plainPointer ? T * x : std::shared_ptr<T> x) { /*implementation*/ }
};  

Ou seja, se plainPointer==true, a seguinte função membro da classe deve ser definida:

void f(T * x) { /*implementation*/ }

caso contrário, esta função membro deverá ser definida:

void f(std::shared_ptr<T> x) { /*implementation*/ }

Eu gostaria de ter uma única implementação para ambas as funções , e apenas o tipo de argumento fdeveria ser plainPointerdependente.

library(ggplot2)
mydat <- data.frame(mean = c(23, 24, 15, 27, 18, 19, 23, 20, 32),
           lower = c(20, 19, 13, 15, 14, 18, 20, 17, 20),
           upper = c(25, 29, 17, 39, 22, 20, 26, 23, 40),
           class = c("A", "B", "C", "A", "B", "C", "A", "B", "C"),
           domain = c("North", "North", "North", "West", "West", "West", "South", "South", "South"))
mydat$class <- as.factor(mydat$class)
mydat$domain <- as.factor(mydat$domain)

mydat %>% ggplot(aes(x = mean, y = class, color = domain, Group = domain, xmin = lower, xmax = upper)) +
  geom_errorbar(width = 0.1, position = position_dodge(width = 0.5)) + theme_light() + geom_point(position = position_dodge(width = 0.5)) + xlab("Counts")

Gostaria de ordenar diminuindo o valor dos limites superiores (ou seja, upper) da barra de erro dentro de cada um classe também entre domains. A saída desejada é esta:

Tentei o seguinte código mas não surtiu o efeito desejado:

library(forcats)
mydat %>% ggplot(aes(x = mean, y = class, color = fct_infreq(domain), Group = fct_infreq(domain), xmin = lower, xmax = upper)) +
  geom_errorbar(width = 0.1, position = position_dodge(width = 0.5)) + theme_light() + geom_point(position = position_dodge(width = 0.5)) + xlab("Counts")

Estou estudando conceptsC++ 20 e surgiu a necessidade de definir a conceptusando um definido anteriormente concept.

Então, no exemplo abaixo eu esperava f<pub_b>()gerar um erro do compilador, pois events_publishedin pub_bnão satisfaz publisherconceito, assim como ev_2não satisfaz eventconceito.

Parece que usar eventconceito em publisherconceito não tem efeito.

g++ versionrelatórios

g++ (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0
Copyright (C) 2021 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

O que estou fazendo de errado?

#include <concepts>
#include <tuple>

template <typename t>
concept event = requires {
  std::default_initializable<t>;
  std::copy_constructible<t>;
  std::move_constructible<t>;
};

struct ev_1 {
  ev_1() = default;
  ev_1(const ev_1 &) = default;
  ev_1(ev_1 &&) = default;
};

struct ev_2 {
  ev_2() = delete;
  ev_2(const ev_2 &) = default;
  ev_2(ev_2 &&) = default;
};

template <typename t>
concept publisher = requires {
  typename t::events_published;

  requires[]<std::size_t... t_idx>(std::index_sequence<t_idx...>) {
    return ((event<typename std::tuple_element_t<
                 t_idx, typename t::events_published>>)&&...);
  }
  (std::make_index_sequence<std::tuple_size_v<typename t::events_published>>());
};

struct pub_a {
  using events_published = std::tuple<ev_1>;
};

struct pub_b {
  using events_published = std::tuple<ev_2>;
};

template <publisher t_publisher> void f() {}

int main() {
  f<pub_a>();

  f<pub_b>();

  return 0;
}

No Thinking With TypesExercício 11.2-i é escrever a função com a seguinte assinatura de tipo.

weaken :: OpenSum f ts -> OpenSum f (x ': ts)

data OpenSum (f :: k -> Type) (ts :: [k]) where
  UnsafeOpenSum :: Int -> f t -> OpenSum f ts 

Acredito que o parágrafo anterior ao exercício forneça contexto suficiente para saber o que essa função realiza, mas não está claro para mim.

Na prática, também é útil poder ampliar as possibilidades de um montante em aberto. Uma nova função, enfraquecer, alinha o tipo machado na frente da lista de possibilidades.

Se eu tivesse alguns exemplos de uso dessa função, seria uma grande ajuda para eu concluir este exercício.

Eu tenho um ggplot onde usei a função geom_smooth(method='gam'). Fiquei me perguntando se existe uma maneira de extrair parâmetros do modelo, como coeficientes e desvios explicados.

Semelhante ao summary() da saída de mgcv::gam():

> summary(gam)

Family: gaussian 
Link function: identity 

Formula:
mAODscale ~ s(numDate, bs = "cr")

Parametric coefficients:
            Estimate Std. Error t value Pr(>|t|)    
(Intercept) 0.041461   0.002198   18.86   <2e-16 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Approximate significance of smooth terms:
             edf Ref.df     F p-value    
s(numDate) 8.731  8.979 74.54  <2e-16 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

R-sq.(adj) =  0.379   Deviance explained = 38.4%
GCV = 0.0053239  Scale est. = 0.0052765  n = 1092

Dados

test <- structure(list(numDate = c(1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 
5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 
11, 11, 12, 12, 12, 13, 13, 13, 14, 14, 14, 15, 15, 15, 16, 16, 
16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 20, 20, 20, 21, 21, 21, 
22, 22, 22, 23, 23, 23, 24, 24, 24, 25, 25, 25, 26, 26, 26, 27, 
27, 27, 28, 28, 28, 29, 29, 29, 30, 30, 30, 31, 31, 31, 32, 32, 
32, 33, 33, 33, 34), mAODscale = c(0.0388813764134284, 0.0461877433707656, 
0.096886995092774, 0.0371438764134382, 0.0394419100374392, 0.0893994950927635, 
0.0413855430800965, 0.0418085767040992, 0.101328661759439, 0.0428313764134316, 
0.0403835767041016, 0.0978328284261067, 0.0444813764134295, 0.0566460767040979, 
0.136811995092771, 0.0404647097467716, 0.0461127433707702, 0.104611995092768, 
0.0391105430800991, 0.0388294100374367, 0.0883828284261057, 0.0377355430801032, 
0.0334335767040983, 0.0744786617594428, 0.0346647097467638, 0.0316752433707705, 
0.0691911617594343, 0.0365730430800966, 0.0329127433707725, 0.0721203284261094, 
0.0337897097467703, 0.0271960767041008, 0.0568703284261005, 0.0321188764134348, 
0.0226835767040967, 0.0467286617594311, 0.0389522097467676, 0.0317169100374315, 
0.0724911617594444, 0.0374147097467699, 0.0301335767041024, 0.066378661759444, 
0.0359688764134347, 0.0245710767041061, 0.0492828284261009, 0.0340355430801083, 
0.0208835767040938, 0.0401828284261114, 0.033193876413435, 0.0170627433707722, 
0.0363119950927739, 0.0320272097467722, 0.0147294100374324, 0.0298161617594417, 
0.0305563764134433, 0.0123752433707693, 0.0200744950927714, 0.0294522097467649, 
0.00966691003743847, 0.0144453284261061, 0.029439709746768, 0.00845441003743019, 
0.0127494950927769, 0.029218876413438, 0.00767941003742578, 0.0118203284260971, 
0.0283438764134303, 0.00608774337077023, 0.00807032842610056, 
0.027393235387791, 0.00498582029383954, 0.00612513611841337, 
0.0261313764134314, 0.004612743370771, 0.00541616175944171, 0.0260813764134298, 
0.00472524337077118, 0.00372449509276862, 0.0256522097467666, 
0.00535024337077061, 0.00356616175943714, 0.0250313764134376, 
0.0161044100374284, 0.00060366175944182, 0.0241147097467689, 
0.025246076704093, -0.00540050490722876, 0.0233022097467739, 
0.022454410037426, -0.00630883824055672, 0.0208772097467715, 
0.0152252433707645, -0.00819217157389573, 0.0194897097467646, 
-0.00307475662923196, -0.00896300490722979, 0.0178938764134386, 
0.00323774337076088, -0.00836717157389444, 0.0153022097467641
)), row.names = c(NA, -100L), class = c("data.table", "data.frame"
), .internal.selfref = <pointer: 0x000002cacef91f60>)

Codifique e plote com geom_smooth()

Nota: isso está usando apenas um subconjunto do meu conjunto de dados.

p <- ggplot(test50, aes(x=numDate, y=mAODscale)) +
  geom_point() +
  stat_smooth(method='gam',
              formula=y~s(x,bs="cs",fx=TRUE,k=10))

É possível ter uma classe com um parâmetro de template opcional que possa ser chamado assim?:

#include <iostream>

template <typename T = void>
class A final
{
public:
    // This class can be called only when T exists.
    void f()
    {
        printf("%d\n", member);
    }

    // This method can be called only when T is missing.
    void g()
    {
        printf("No template parameter\n");
    }
public:
    T member;
};

int main()
{

    A<int> a1;
    A a2;
    a1.f(); // should be valid
    a1.g(); // should be invalid, cannot compile
    a2.f(); // should be invalid, cannot compile
    a2.g(); // should be valid

    return 0;
}

Se sim, quais são as funções padrão que devem ser usadas?