All perguntas(coding)

Eu estava lendo a documentação do GNU/GCC e parei na descrição do __attribute__ ((packed)). Diz:

embalado

O atributo compactado especifica que um campo de variável ou estrutura deve ter o menor alinhamento possível – um byte para uma variável e um bit para um campo, a menos que você especifique um valor maior com o atributo alinhado.

Aqui está uma estrutura na qual o campo x é compactado, de modo que segue imediatamente a:

struct foo
{
    char a;
    int x[2] __attribute__ ((packed));
};

Gostaria de saber como esse atributo funciona exatamente e se esse código:

struct bar
{
    char a:1 __attribute__ ((packed));
};

criaria uma estrutura de 1 bit em vez de 1 byte.

o aplicativo ainda mostra apenas uma tela em branco. Aqui está o código principal do meu aplicativo:

import 'package:flutter/material.dart';
import 'package:firebase_core/firebase_core.dart';

void main() async {
  await Firebase.initializeApp();
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('Firebase Integration')),
        body: Center(child: Text('Hello, Firebase!')),
      ),
    );
  }
}

Qualquer ajuda ou sugestão seria muito apreciada!

Em uma classe sem herança, esperaria que a virtualpalavra-chave não tivesse nenhum efeito perceptível. No entanto, no exemplo de código a seguir, adicioná-lo interrompe a compilação. Eu gostaria de entender o mecanismo por trás disso. Por que a virtualpalavra-chave interrompe a compilação?

Compila bem sem a palavra-chave virtual.

#define USE_VIRTUAL 1
// compile with: cl /W4 /EHsc main.cpp /link /out:main.exe
#include<iostream>
#include<memory>

struct Dummy {int i = 3;};
class Uncopyable {
    public:
        // Implicitly delete the copy constructor by having
        // a non-copyable member.
        std::unique_ptr<Dummy> m_innerPtr;

        // A virtual destructor to allow correct inheritance.
        // I first thought that this implicitly deletes the 
        // copy-assignment and copy-constructor, 
        // but it does not. It does, however, implicitly
        // delete the move constructor and assignment.
        virtual ~Uncopyable() = default;

        // accessible constructor
        Uncopyable() = default;
        Uncopyable(std::unique_ptr<Dummy> dummy):m_innerPtr(std::move(dummy)){};

};


template <typename MaybeCopyable>
class Bamboozle {
    public: 
    void foo(std::shared_ptr<MaybeCopyable> obj) {
        std::cout << "Reached Bamboozle::foo(shared_ptr)" << std::endl;
    }

    // overload that takes an object by value
#if USE_VIRTUAL
    virtual
#endif
    void foo(MaybeCopyable obj){
        std::cout << "Reached Bamboozle::foo(Uncopyable)" << std::endl;
        foo(std::make_shared<Uncopyable>(std::move(obj)));
    }
};



int main(int argc, char** argv){
    // construct param objects
    std::shared_ptr<Uncopyable> uncSharedPtr = std::make_shared<Uncopyable>();

    // prints Bamboozle::foo(shared_ptr)
    Bamboozle<Uncopyable> bamboozleObj;
    bamboozleObj.foo(uncSharedPtr);
    return 0;
};

Veja esta questão (fechada por ser muito detalhada) para obter mais contexto se quiser ler sobre outros aspectos que acho que estão envolvidos nisso. Especificamente modelos e construtores de movimentos. O modelo de classe é necessário para reproduzir esse comportamento.

A mensagem de erro é:

cl /W4 /EHsc main.cpp /link /out:main.exe
Microsoft (R) C/C++ Optimizing Compiler Version 19.38.33134 for x64
Copyright (C) Microsoft Corporation.  All rights reserved.

main.cpp
main.cpp(46): warning C4100: 'argv': unreferenced formal parameter
main.cpp(46): warning C4100: 'argc': unreferenced formal parameter
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\xutility(255): error C2280: 'Uncopyable::Uncopyable(const Uncopyable &)': attempting to reference a deleted function
main.cpp(24): note: compiler has generated 'Uncopyable::Uncopyable' here
main.cpp(24): note: 'Uncopyable::Uncopyable(const Uncopyable &)': function was implicitly deleted because a data member invokes a deleted or inaccessible function 'std::unique_ptr<Dummy,std::default_delete<Dummy>>::unique_ptr(const std::unique_ptr<Dummy,std::default_delete<Dummy>> &)'
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\memory(3319): note: 'std::unique_ptr<Dummy,std::default_delete<Dummy>>::unique_ptr(const std::unique_ptr<Dummy,std::default_delete<Dummy>> &)': function was explicitly deleted
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\xutility(255): note: the template instantiation context (the oldest one first) is
main.cpp(51): note: see reference to class template instantiation 'Bamboozle<Uncopyable>' being compiled
main.cpp(38): note: while compiling class template member function 'void Bamboozle<Uncopyable>::foo(MaybeCopyable)'
        with
        [
            MaybeCopyable=Uncopyable
        ]
main.cpp(40): note: see reference to function template instantiation 'std::shared_ptr<Uncopyable> std::make_shared<Uncopyable,Uncopyable>(Uncopyable &&)' being compiled
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\memory(2769): note: see reference to function template instantiation 'std::_Ref_count_obj2<_Ty>::_Ref_count_obj2<_Ty>(_Ty &&)' being compiled
        with
        [
            _Ty=Uncopyable
        ]
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\memory(2094): note: see reference to function template instantiation 'void std::_Construct_in_place<_Ty,_Ty>(_Ty &,_Ty &&) noexcept(false)' being compiled
        with
        [
            _Ty=Uncopyable
        ]

Quero que o div azul diminua e permita que o div verde ocupe mais espaço quando não houver muito conteúdo no div azul e vice-versa. No entanto, nenhum dos divs poderá ultrapassar 50% do contêiner se houver muito conteúdo em ambos os divs.

.container {
  display: flex;
  flex-direction: column;
  height: 300px;
}

.topDiv {
  background-color: blue;
  color: white;
  flex: 1;
  overflow: auto;
}

.bottomDiv {
  background-color: green;
  color: white;
  flex: 1;
  overflow: auto;
}

<div class="container">
    <div class="topDiv">
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
    </div>
    <div class="bottomDiv">
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
    </div>
  </div>

Aqui está o protótipo da função SystemTimeToTzSpecificLocalTime:

BOOL SystemTimeToTzSpecificLocalTime(
  [in, optional] const TIME_ZONE_INFORMATION *lpTimeZoneInformation,
  [in]           const SYSTEMTIME            *lpUniversalTime,
  [out]          LPSYSTEMTIME                lpLocalTime
);

Como você pode ver, o segundo e o terceiro parâmetros são ponteiros para estruturas SYSTEMTIME, portanto, pelo menos do ponto de vista da verificação de tipo estática, deve ser possível passar o mesmo ponteiro para ambos os parâmetros.

No entanto, a documentação não diz nada sobre se isso é seguro ou não.

Em meus testes, descobri que passar o mesmo ponteiro para ambos os parâmetros funciona conforme o esperado. A função modifica a estrutura SYSTEMTIME e a saída está correta.

Aqui está um exemplo simples:

#include <windows.h>
void main() {
    SYSTEMTIME tm;
    GetSystemTime(&tm);
    SystemTimeToTzSpecificLocalTime(NULL, &tm, &tm);
    wprintf(L"Local Time: %02d:%02d:%02d\n", tm.wHour, tm.wMinute, tm.wSecond);
}

Minha pergunta é: é seguro passar o mesmo ponteiro para ambos os parâmetros? Ou devo usar uma nova estrutura SYSTEMTIME para a saída?

Não consegui encontrar nenhuma informação sobre isso na documentação. ( https://learn.microsoft.com/en-us/windows/win32/api/timezoneapi/nf-timezoneapi-systemtimetotzspecificlocaltime )

Obrigado!

Por quanto tempo um parâmetro (capturado por valor) dentro de uma expressão lambda é válido? O parâmetro é válido durante a vida útil do próprio lambda ou é válido apenas durante a chamada?

Por exemplo, dado isto:

[value = 5] { DoSomething(&value) }

O &valueponteiro permanece válido após o término da chamada lambda? (Claro, supondo que o lambda em si ainda esteja vivo.)

Eu já vi essa pergunta com nome semelhante, mas trata da modificação do lambda dentro da expressão, não do tempo de vida.

Para responder aos comentários, também suspeito valueque seja capturado como membro (e portanto deveria permanecer vivo fora da expressão). Mas estou preocupado que isso possa estar errado porque valueteoricamente poderia ser capturado como um membro, mas depois passado para a própria expressão por valor (e, portanto, a referência que vemos não permaneceria viva).

Eu tenho uma string UTF-8 que desejo pesquisar todas as ocorrências de img_(\d+). Eu tentei original

$pattern = '/img_(\d+)/u';
preg_match_all($pattern, $text, $matches, PREG_OFFSET_CAPTURE);

mas isso me dá compensações erradas para os padrões.

Eu também tentei:

mb_internal_encoding('UTF-8');
$pattern = 'img_(\d+)';
mb_ereg_search_init($content, $pattern);

$matches = [];        
while ($result = mb_ereg_search_regs()) {
    $matches[] = [
        'match' => $result[0],
        'offset' => mb_ereg_search_getpos() - mb_strlen($result[0]),
    ];
}

mas me dá o mesmo resultado que preg_match_all.

No entanto, quando executo manualmente a pesquisa com isto:

$pos = mb_strpos($content, "img_1", 0);

Eu obtive o deslocamento correto.

Código de exemplo:

$str = "příliš žluťoučký img_1 kůn úpěl ďábelské ódy";

$pattern = '/img_(\d+)/u';
preg_match_all($pattern, $str, $matches, PREG_OFFSET_CAPTURE);

print_r($matches); //gives 24 (wrong)

echo mb_strpos($str, "img_1", 0); //gives 17 (correct)

Como consertar isto?

Considere o seguinte exemplo simples:

use std::cell::RefCell;

// Compiles fine
fn good(t: RefCell<String>) -> bool {
    t.borrow().len() == 12
}

// error[E0597]: `t` does not live long enough
fn bad(t: RefCell<String>) -> bool {
    let t = t;
    t.borrow().len() == 12
}

Parque infantil

A badfunção falha ao compilar com o seguinte erro:

error[E0597]: `t` does not live long enough
  --> src/lib.rs:9:5
   |
8  |     let t = t;
   |         - binding `t` declared here
9  |     t.borrow().len() == 12
   |     ^---------
   |     |
   |     borrowed value does not live long enough
   |     a temporary with access to the borrow is created here ...
10 | }
   | -
   | |
   | `t` dropped here while still borrowed
   | ... and the borrow might be used here, when that temporary is dropped and runs the destructor for type `Ref<'_, String>`
   |
   = note: the temporary is part of an expression at the end of a block;
           consider forcing this temporary to be dropped sooner, before the block's local variables are dropped
help: for example, you could save the expression's value in a new local variable `x` and then make `x` be the expression at the end of the block
   |
9  |     let x = t.borrow().len() == 12; x
   |     +++++++                       +++

Isso parece extremamente estranho para mim. Apenas reatribuir o parâmetro de função a variáveis ​​locais falha na compilação. Você poderia explicar por quê?

No JavaFX, FXMLLoadercria automaticamente o controlador especificado em um arquivo .fxml usando o construtor 0-arg. Ele também fornece métodos para definir/criar o controlador manualmente usando FXMLLoader#setControllerou FXMLoader#setControllerFactory.

Minha pergunta agora é qual é a diferença entre eles? Existem situações em que um é melhor que o outro?

A documentação de ambos os métodos realmente não responde à minha pergunta.

Ao escrever assembly embutido, existe uma maneira de forçar o uso do prefixo rex.W?

Então, em vez de

"psllq $12, %%xmm1\n"

gerando 66 0f 73 f1 0c, eu quero 66 48 0f 73 f1 0c, com o prefixo 0x48 rex.W extra.

EDIT: Cometi um erro com o título inicial, o problema é com o clang e não com o GCC.

insn_sse2.c:11794:11: error: unexpected token in argument list
         "rex.W psllq $12, %%xmm1\n"
          ^
<inline asm>:7:13: note: instantiated into assembly here
rex.W psllq $12, %xmm1