Programação on kenji.blog

Como resolver quando você não consegue cancelar o Google One (Gemini)

Sat, 27 Sep 2025 10:02:59 +0900

[Aviso] Serei cobrado quando o teste gratuito do Gemini terminar? Resumo de como cancelar

Quando você tenta experimentar o serviço de IA do Google “Gemini”, primeiro é oferecido um teste gratuito de 1 mês . Muitas pessoas podem pensar “Se é gratuito, vou tentar por enquanto” e se registrar, mas há um ponto de atenção aqui.

O que acontece quando o teste gratuito termina?

Quando o período de teste termina, uma cobrança de 2.900 ienes por mês é feita automaticamente. Isso está vinculado a uma assinatura chamada “Assinatura do Google One” e, se você não fizer nada em particular, o sistema fará a transição para faturamento contínuo.

Se você cancelar, não será cobrado, mas…

Claro, se você cancelar durante o período de teste, nenhuma taxa será gerada. A página de explicação oficial também mostra “Como cancelar a assinatura do Google One”.

👉 Cancelar a assinatura do Google One (oficial)

No entanto, quando você realmente acessa, você se depara com a situação de “Por algum motivo, não consigo cancelar…”. Fiquei confuso pensando: “Ué, por onde devo cancelar?”.

O método de cancelamento correto está aqui!

Após várias pesquisas, a página da qual eu consegui realmente cancelar foi a seguinte.

👉 Conta do Google – Excluir serviços

A partir daqui, se você selecionar “Google One” e excluí-lo, o cancelamento será concluído.

Resumo

O teste gratuito do Gemini dura 1 mês
Após o término, uma taxa de 2.900 ienes por mês será cobrada automaticamente
O cancelamento pode não ser possível pela página de explicação oficial
Você pode realmente cancelar pela página “Excluir serviços”

Se você pensar “Tudo bem porque é um teste gratuito”, você pode ser cobrado sem perceber, então tome cuidado!

👉 Se você está lendo este artigo, talvez esteja tendo problemas agora, pensando: “De onde eu cancelo?”. De qualquer forma, verifique através do link acima.

Como remover em lote metadados (informações pessoais) do Excel, Word, etc. usando o PowerShell

Wed, 30 Jul 2025 02:42:40 +0900

“Como remover em lote metadados (informações pessoais) do Excel, Word, etc. usando o PowerShell”

Arquivos do Office como o Excel salvam automaticamente “metadados (informações pessoais)”, como o criador, a última pessoa a modificar e o nome da empresa. Há muitos casos em que você deseja remover essas informações, como ao compartilhar um arquivo fora da empresa.

Neste artigo, explicaremos em detalhes como remover os metadados do Excel usando o PowerShell, focando em ** processamento em lote em uma pasta ** e ** aplicação a outros arquivos do Office, como Word e PowerPoint ** .

1. Remover os metadados de um único arquivo do Excel

Este é o script mais básico para remover informações pessoais de um único arquivo do Excel. Ele chama o objeto COM do Excel, define a propriedade RemovePersonalInformation como $true e salva sobrescrevendo o arquivo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# Iniciar o aplicativo Excel de forma oculta
$excel = New-Object -ComObject Excel.Application
$excel.Visible = $false
$excel.DisplayAlerts = $false

# Abrir o arquivo (*especifique o caminho absoluto)
$filePath = "C:\Path\To\Your\File.xlsx"
$wb = $excel.Workbooks.Open($filePath)

# Ativar a configuração para remover metadados (informações pessoais)
$wb.RemovePersonalInformation = $true

# Salvar e fechar
$wb.Save()
$wb.Close($false)

# Sair do Excel e liberar memória
$excel.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($excel) | Out-Null

** Atenção: ** Certifique-se de especificar o ** caminho absoluto (caminho completo) ** para o caminho passado para Workbooks.Open(). Um caminho relativo pode resultar em erro.

2. Processar todos os arquivos do Excel em uma pasta em lote

Na prática, muitas vezes você deseja “excluir todos os metadados de dezenas de arquivos do Excel em uma pasta específica de uma vez”. Isso pode ser feito usando um loop em combinação com Get-ChildItem.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


$targetFolder = "C:\Path\To\Your\Folder"

# Obter todos os arquivos .xlsx e .xls na pasta
$excelFiles = Get-ChildItem -Path $targetFolder -Include "*.xlsx", "*.xls" -Recurse

if ($excelFiles.Count -eq 0) {
 Write-Host "Nenhum arquivo do Excel encontrado."
 exit
}

$excel = New-Object -ComObject Excel.Application
$excel.Visible = $false
$excel.DisplayAlerts = $false

foreach ($file in $excelFiles) {
 Write-Host "Removendo metadados de $($file.Name)..."

 # Abrir o arquivo
 $wb = $excel.Workbooks.Open($file.FullName)

 # Remover metadados e salvar
 $wb.RemovePersonalInformation = $true
 $wb.Save()
 $wb.Close($false)
}

$excel.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($excel) | Out-Null

Write-Host "Todo o processamento foi concluído!"

3. Remover metadados de outros arquivos do Office (Word / PowerPoint)

Os metadados podem ser removidos com exatamente a mesma lógica não apenas no Excel, mas também no Word e no PowerPoint. Apenas o nome do objeto COM a ser chamado é diferente, e é comum que a propriedade RemovePersonalInformation seja fornecida.

Para o Word

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$word = New-Object -ComObject Word.Application
$word.Visible = $false
$word.DisplayAlerts = 0

$doc = $word.Documents.Open("C:\Path\To\Your\File.docx")
$doc.RemovePersonalInformation = $true
$doc.Save()
$doc.Close()

$word.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($word) | Out-Null

Para o PowerPoint

Para o PowerPoint, a configuração da propriedade RemovePersonalInformation é semelhante, mas o comportamento da inicialização oculta é ligeiramente diferente.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


$ppt = New-Object -ComObject PowerPoint.Application

# Abrir especificando o modo oculto (msoFalse) etc. com os 2º a 4º argumentos
$presentation = $ppt.Presentations.Open("C:\Path\To\Your\File.pptx", $false, $false, $false)
$presentation.RemovePersonalInformation = $true
$presentation.Save()
$presentation.Close()

$ppt.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($ppt) | Out-Null

Conclusão

Ao utilizar o PowerShell e objetos COM, você pode automatizar completamente a remoção de metadados de arquivos do Office. É muito útil ter um script de processamento em lote em mãos antes da entrega, a fim de evitar o vazamento não intencional de informações confidenciais ou nomes pessoais.

Passos para chamar o TinyLLaMA a partir de C++ (usando llama.cpp)

Sat, 19 Jul 2025 09:40:53 +0900

✅ Configuração do TinyLLaMA × C++ (usando `llama.cpp`)

🔧 Passo 1: Preparar o llama.cpp

1-1. Ambiente necessário (Mínimo)

OS: Windows / Linux / macOS
Ambiente de desenvolvimento: g++ / clang / MSVC
Git / CMake

1-2. Obter e compilar llama.cpp

1
2
3
4
5
6


git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build
cd build
cmake ..
cmake --build . --config Release

No Windows, é mais fácil usar Visual Studio Developer Command Prompt com cmake --build . --config Release.

📦 Passo 2: Baixar e converter o modelo TinyLLaMA

2-1. Obter o modelo original do HuggingFace

Exemplo: TinyLLaMA-1.1B

1
2
3
4
5
6
7


# Instalar transformers para download, se necessário
pip install transformers huggingface_hub

python3 -m transformers.models.llama.convert_llama_weights_to_hf \
 --input_dir ./TinyLlama-1.1B-Chat \
 --model_size 1B \
 --output_dir ./hf_model

Este é o passo para converter para o formato Hugging Face.

2-2. Converter para formato GGUF (para `llama.cpp`)

1
2


cd llama.cpp
python3 convert.py ./hf_model --outfile tinyllama.gguf

2-3. Quantização do modelo (redução de tamanho)

1

./quantize ./tinyllama.gguf ./tinyllama-q4.gguf q4_0

q4_0 é a quantização em 4 bits. O tamanho do modelo será reduzido para cerca de ** 350MB ** .

🧪 Passo 3: Chamar o modelo a partir do C++ (Exemplo de código)

3-1. Código C++ simples (Inferência)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


#include "llama.h"
#include <iostream>

int main() {
 llama_model_params model_params = llama_model_default_params();
 llama_context_params ctx_params = llama_context_default_params();

 llama_model *model = llama_load_model_from_file("tinyllama-q4.gguf", model_params);
 llama_context *ctx = llama_new_context_with_model(model, ctx_params);

 std::string prompt = "O utilizador diz que quer carregar dados do Excel, filtrá-los e guardá-los. Qual é a configuração dos nós?";
 llama_batch batch = llama_batch_init(512, 0, 1);
 llama_token BOS = llama_token_bos(model);
 batch.token[0] = BOS;

 // Tokenização
 std::vector<llama_token> tokens(prompt.size() + 8);
 int n = llama_tokenize(model, prompt.c_str(), tokens.data(), tokens.size(), true);
 tokens.resize(n);

 for (size_t i = 0; i < tokens.size(); ++i) {
 batch.token[i + 1] = tokens[i];
 }

 batch.n_tokens = tokens.size() + 1;
 llama_decode(ctx, batch);

 // Obter resultado da inferência
 for (int i = 0; i < 50; ++i) {
 llama_token next = llama_sample_token(ctx, nullptr);
 std::cout << llama_token_to_str(model, next);
 llama_batch next_batch = llama_batch_init(1, 0, 1);
 next_batch.token[0] = next;
 next_batch.n_tokens = 1;
 llama_decode(ctx, next_batch);
 }

 llama_free(ctx);
 llama_free_model(model);
 return 0;
}

🧱 Passo 4: Como compilar (Exemplo)

1

g++ -I./llama.cpp main.cpp ./llama.cpp/build/libllama.a -o tiny_infer -pthread -std=c++11

libllama.a será criado no diretório build/ após a compilação.

✅ Exemplo de estrutura dos artefactos (Organização)

1
2
3
4
5
6


my_app/
├── tinyllama-q4.gguf # Modelo quantizado (~350MB)
├── main.cpp # Código C++ acima
├── llama.cpp/ # Diretório do llama.cpp
└── build/
 └── libllama.a # Biblioteca compilada

🧠 Notas adicionais para aplicação em casos de uso

Ter código em C++ para verificar e selecionar o modelo de nós com base na saída
Exemplo: Se contém “Excel”, “filtro”, “guardar” → gera os grupos de nós correspondentes
Esta parte pode ter uma estrutura simples, como instruções if + carregamento de modelo JSON

📌 Resumo

Item	Descrição
Modelo recomendado	TinyLLaMA-1.1B-Chat v1.0 (GGUF + Quantização)
Tamanho	~350 a 450MB (Quantização 4bit)
Integração C++	Possível através de `llama.cpp`, quase sem dependências externas
Capacidade de processamento	Suficiente para compreensão básica de intenções e geração de frases (Texto natural → Estrutura)
Extensibilidade	Pode tornar-se uma IA de geração de nós quando combinado com preenchimento de slots e chamadas de modelos

Vantagens e Desvantagens de Criar Programas com Win32API + C++

Sat, 12 Jul 2025 12:30:35 +0900

O Fascínio e os Desafios de Desenvolver com Win32API + C++

Para aqueles que desejam dominar o desenvolvimento de aplicativos do Windows, Win32API + C++ ainda é uma opção poderosa. Esta combinação, que permite a interação mais próxima possível com o sistema operacional, oferece velocidade e flexibilidade.

Por outro lado, requer determinação para ser dominada, pois difere significativamente dos estilos de desenvolvimento modernos.

Nesta página, explicaremos de forma clara as vantagens e desvantagens a partir da perspectiva de um desenvolvedor ativo de aplicativos do Windows .

Vantagens

Execução Nativa Ultrarrápida

Como o C++ e a Win32API operam na camada mais próxima do sistema operacional, há muito pouca sobrecarga desnecessária. O uso de CPU e memória é extremamente eficiente, ostentando uma velocidade de execução esmagadora .

Alta Flexibilidade e Liberdade

Você pode controlar finamente por conta própria todos os comportamentos do aplicativo, como controle de janelas, processamento assíncrono, integração COM e gerenciamento de processos. Também é possível construir ferramentas especializadas e seus próprios frameworks originais.

Fácil de Distribuir sem Necessidade de Runtime

Como não são necessários runtimes externos como .NET ou Java, ele pode ser distribuído como um único arquivo executável . É menos propenso a problemas durante a redistribuição e é fácil de executar sem um instalador.

Pode Criar Aplicativos Leves

Como requer apenas a configuração mínima necessária, sua característica é ter uma pegada de memória muito pequena . Ele funciona confortavelmente mesmo em PCs de baixas especificações ou ambientes de máquinas virtuais.

Controle Avançado em Nível de SO Possível

Você também pode obter controles que são difíceis com linguagens e bibliotecas normais , como ganchos globais de mouse e teclado, ajuste fino de estilos de janelas e operações do menu do sistema.

Desvantagens

Baixa Eficiência de Desenvolvimento

Até a construção da GUI deve ser feita inteiramente em código, e às vezes dezenas de linhas de código são necessárias apenas para criar um único botão . Modificar o design também é complicado, e a produtividade é menor em comparação ao desenvolvimento usando frameworks de UI.

Fácil de Reduzir a Manutenibilidade

Existem muitos códigos com estruturas especiais , como loops de mensagens e procedimentos de janelas, dificultando a legibilidade e a reutilização. Também tem aspectos inadequados para desenvolvimento em equipe e manutenção a longo prazo.

Difícil de Suportar UI Moderna

É difícil suportar a UX exigida nos últimos anos , como suporte a alto DPI, interfaces de toque, acessibilidade e modo escuro. Você precisa lidar com cada um manualmente, o que exige muito esforço.

Não Suporta Multiplataforma

Como é uma API completamente exclusiva do Windows, não pode ser portada para macOS ou Linux . Se você planeja implantação em várias plataformas, precisará selecionar outras tecnologias.

Custo de Aprendizado Extremamente Alto

Você deve entender conceitos e mecanismos raramente usados hoje , como manipuladores, GDI, COM e OLE. Muitos documentos são antigos, exigindo tempo e paciência para aprender.

Usos Adequados

Ferramentas leves , como iniciadores de arquivos e suportes de teclas de atalho
Utilitários do sistema , como manipulação da área de transferência e controle de IME
Aplicativos baseados em controle nativo , como ganchos globais e captura de janelas
Ferramentas de suporte de driver intimamente ligadas ao hardware

Usos Inadequados

Aplicativos voltados para o consumidor em geral onde UI / UX modernos são importantes
Desenvolvimento de protótipos e MVP construídos com velocidade em mente
Projetos de grande escala baseados em operação de longo prazo e desenvolvimento em equipe
Produtos multiplataforma que precisam suportar vários sistemas operacionais

Resumo da Avaliação

Ponto de Vista	Avaliação
Velocidade de Execução	◎ Muito Rápido
Eficiência de Memória	◎ Excelente
Velocidade de Desenvolvimento	× Lenta
Manutenibilidade	× Baixa
Suporte Multiplateforma	× Não Suportado
Suporte UI Moderna	× Fraco
Liberdade de Controle do SO	◎ Esmagadoramente Alta

Conclusão

Win32API + C++ é uma ferramenta para desenvolvedores que “desejam lidar com tudo no sistema operacional por conta própria”. Embora seu poder seja imenso, o aprendizado e a operação exigem uma quantidade correspondente de determinação.

Se vale a pena “escolher ousadamente” depende da natureza do aplicativo que você pretende.

Mergulhar no mundo de #include <windows.h> sem depender de frameworks de GUI ou linguagens modernas ―― Essa escolha ainda é significativa hoje.

FizzBuzz

Fri, 18 Apr 2025 00:58:11 +0900

Afinal, o que é FizzBuzz?

Olá!

Hoje eu gostaria de escrever sobre “FizzBuzz”.

Tanto para aqueles que pensam “Ah, eu conheço isso!”, quanto para aqueles que dizem “Já ouvi falar, mas não entendo muito bem”, por favor, fiquem comigo um pouquinho. Pode ser lido em poucos minutos, e talvez você pense “Faz sentido”.

É verdade que “se você não consegue escrever FizzBuzz, você é um fracasso como programador”?

O FizzBuzz, em resumo, é assim.

1
2
3
4
5
6
7
8
9


for i in range(1, 101):
 if i % 15 == 0:
 print("FizzBuzz")
 elif i % 3 == 0:
 print("Fizz")
 elif i % 5 == 0:
 print("Buzz")
 else:
 print(i)

Sim, este é o famoso “Problema FizzBuzz”.

Você analisa os números de 1 a 100 em ordem,
se for um múltiplo de 3, exibe “Fizz”, se for um múltiplo de 5, exibe “Buzz”,
se for um múltiplo de ambos, exibe “FizzBuzz” - é algo muito simples.

E, no entanto, por algum motivo, costuma ser tratado como “o teste mínimo para um programador”. Aparece em entrevistas, e nas redes sociais você vê comentários do tipo “Alguém que não consegue nem escrever FizzBuzz…”.

Mas, espere um minuto.

Podemos realmente dizer que “não conseguir escrever FizzBuzz = não conseguir programar”?

Não é sobre poder ou não, mas se você tem o “estado” para poder

É verdade que o FizzBuzz exige compreensão da sintaxe e pensamento lógico básico. Portanto, faz sentido que seja usado para “verificar os fundamentos”.

Mas, veja bem.

Se o ambiente for diferente, os resultados serão diferentes.

Por exemplo,

Quando você está nervoso na frente de um entrevistador que acabou de conhecer
Quando você recebe um quadro branco de repente e não tem um editor à mão
Quando você não consegue se lembrar imediatamente de “Ei, o que é modulo?”

…Isso não acontece? Somos humanos. Eu acho que acontece.

Portanto, em vez de “conseguir escrever FizzBuzz”, acho que “conseguir se colocar em um estado em que consiga escrever FizzBuzz” é, na verdade, muito mais importante.

A armadilha do conselho comum de “Basta treinar e ficará tudo bem”

Quando se trata desse assunto, o conselho “Então pratique todos os dias!” tende a surgir.

É verdade que a prática repetida fará com que você o escreva com fluência, e isso em si é bom. Mas se partirmos da premissa de que “se você não conseguir escrever FizzBuzz, você é um fracasso”, isso pode se transformar em mero medo.

Em outras palavras, tende a criar uma estrutura onde você sente “Eu cometi um erro = sou inútil”.

Por exemplo, quando você acorda tarde, você não tende a pensar “Eu sou preguiçoso…”? Mas pode ser apenas que seu corpo estivesse cansado naquele momento.

O FizzBuzz é a mesma coisa.

Dito isto, o FizzBuzz ainda é uma boa pergunta

Dito isto, o FizzBuzz não é ruim.

Em vez disso, acho que é uma pergunta muito bem elaborada. As regras são simples e é fácil de expandir. Por exemplo, se você mudá-lo assim, seu pensamento se aprofundará.

1
2
3
4
5
6
7


for i in range(1, 101):
 output = ""
 if i % 3 == 0:
 output += "Fizz"
 if i % 5 == 0:
 output += "Buzz"
 print(output or i)

Este é um exemplo de “Você pode escrever isso mesmo sem usar if-elif-else”. É meio inteligente, não é?

Em outras palavras, o FizzBuzz não trata apenas de “se você conseguiu fazer”, mas também serve como ponto de partida para ver “como você o escreve” e “o quanto você entende”.

Por tanto

Acho que não devemos atribuir muito significado excessivo a se você consegue ou não fazer o FizzBuzz.

Mesmo que você não tenha conseguido escrever, pode ser apenas que “você não estava se sentindo bem agora”, e muitas vezes você conseguirá se pensar com cuidado mais tarde.

Não se apresse, vamos avançar devagar.

O código é escrito por humanos. Porque somos humanos, às vezes esquecemos coisas e ficamos nervosos. Aceitando isso, acho que basta se pudermos avançar pouco a pouco.

Então, vamos escrever o código de maneira descontraída hoje.

Torre de Hanói

Thu, 17 Apr 2025 22:23:14 +0900

Torre de Hanói

Olá!

Hoje, gostaria de explicar sobre a “Torre de Hanói”, usando um programa de exemplo em Python.

O que é a Torre de Hanói?

A Torre de Hanói é um quebra-cabeça que usa 3 hastes e vários discos. Os discos têm tamanhos diferentes e, no início, estão empilhados em uma haste em ordem decrescente de tamanho. As regras são as seguintes:

Apenas um disco pode ser movido por vez.
Não é possível colocar um disco maior em cima de um disco menor.

Este quebra-cabeça é considerado um excelente material de ensino para aprender o pensamento recursivo. A recursividade é um método de resolver um problema dividindo-o em problemas menores do mesmo tipo. Na Torre de Hanói, para mover n discos, repete-se a operação de mover n-1 discos.

Vamos resolver a Torre de Hanói com Python

Abaixo está um código de exemplo para resolver a Torre de Hanói em Python.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def hanoi(n, source, target, auxiliary):
 if n == 1:
 print(f"Move disk 1 from {source} to {target}")
 return
 hanoi(n - 1, source, auxiliary, target)
 print(f"Move disk {n} from {source} to {target}")
 hanoi(n - 1, auxiliary, target, source)

# Exemplo: Mover 3 discos de A para C
hanoi(3, 'A', 'C', 'B')

Neste código, a função hanoi é chamada recursivamente e os passos para mover os discos são exibidos. Por exemplo, no caso de 3 discos, a seguinte saída é obtida:

1
2
3
4
5
6
7


Move disk 1 from A to C
Move disk 2 from A to B
Move disk 1 from C to B
Move disk 3 from A to C
Move disk 1 from B to A
Move disk 2 from B to C
Move disk 1 from A to C

Desta forma, ao usar uma abordagem recursiva, problemas complexos podem ser resolvidos de forma simples.

Quanto tempo leva para mover 64 discos?

O número de movimentos na Torre de Hanói requer no mínimo 2^n - 1 vezes. Ou seja, para mover 64 discos, são necessários 2^64 - 1 movimentos, o que dá aproximadamente 1,84×10^19 movimentos. Mesmo que você pudesse mover um por segundo, levaria cerca de 584 bilhões de anos. Isso é cerca de 42 vezes a idade do universo (aproximadamente 13,7 bilhões de anos).

Desta forma, conforme o número de discos aumenta, o número necessário de movimentos aumenta exponencialmente. Portanto, mover 64 discos na prática não é realista.

Resumo

A Torre de Hanói é um quebra-cabeça perfeito para aprender o pensamento recursivo. Com Python, você pode facilmente implementar a sua solução. No entanto, é preciso ter cuidado, pois à medida que o número de discos aumenta, o número de movimentos necessários aumenta drasticamente.

Ao entender a abordagem recursiva e tentar escrever código de fato, você pode melhorar suas habilidades de programação. Por favor, experimente enfrentar o desafio da Torre de Hanói.

Passos para Executar o PowerShell a partir de C++ via DLL C++/CLI

Wed, 16 Apr 2025 01:58:03 +0900

🎯 Passos para Executar o PowerShell a partir de C++ via DLL C++/CLI (Visual Studio 2022 / C++)

✅ Visão Geral da Arquitetura

🔹 ① DLL Wrapper CLI (C++/CLI)

Fornece a funcionalidade para executar scripts do PowerShell.

🔹 ② Chamador Nativo C++

Chama a DLL CLI para executar o script do PowerShell.

🔧 Passo 1: Criando o Projeto DLL Wrapper CLI

1. Criar o Projeto

[Criar um novo projeto] → [C++] → Biblioteca de Classes CLR (.NET Framework)
Nome: PowerShellWrapper

💡 Se este modelo não for exibido, instale a carga de trabalho “Desenvolvimento para desktop com .NET”.

2. Adicionar o Pacote NuGet

Clique com o botão direito no projeto → [Gerenciar Pacotes NuGet]
Pesquise e instale System.Management.Automation
(Versão 5.x ou 7.x)

3. Implementação do Código CLI

PowerShellWrapper.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#pragma once

using namespace System;

namespace PowerShellWrapper {
 public ref class PowerShellExecutor {
 public:
 String^ Execute(String^ script);
 };
}

PowerShellWrapper.cpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include "PowerShellWrapper.h"
using namespace System;
using namespace System::Management::Automation;
using namespace System::Collections::ObjectModel;

String^ PowerShellWrapper::PowerShellExecutor::Execute(String^ script)
{
 PowerShell^ ps = PowerShell::Create();
 ps->AddScript(script);
 Collection<PSObject^>^ results = ps->Invoke();

 System::Text::StringBuilder^ sb = gcnew System::Text::StringBuilder();
 for each (PSObject^ result in results)
 {
 sb->AppendLine(result->ToString());
 }

 return sb->ToString();
}

🔧 Passo 2: Chamando a partir do C++ Nativo

1. Criar o Projeto de Aplicativo de Console C++

Nome: NativeApp

2. Adicionar Referência

Clique com o botão direito no projeto → [Adicionar] → [Referência] → Projetos → Adicione PowerShellWrapper
[Propriedades] → [C/C++] → [Suporte a Common Language Runtime] → Mude para /clr

3. Código de Execução (main.cpp)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#using <System.dll>
#using "..\\PowerShellWrapper\\Debug\\PowerShellWrapper.dll"

using namespace System;
using namespace PowerShellWrapper;

int main()
{
 PowerShellExecutor^ executor = gcnew PowerShellExecutor();
 String^ result = executor->Execute("Get-Process | Select-Object -First 1");
 Console::WriteLine(result);
 return 0;
}

💡 Informações Adicionais (IDL / TLB / Registro COM)

Esta configuração faz referência direta à DLL .NET em vez de usar COM, portanto, IDL, TLB ou registro COM não são necessários .

✅ Estrutura Final

1
2
3
4
5


Solution
├── PowerShellWrapper (C++/CLI DLL)
│ └── PowerShellExecutor
├── NativeApp (C++ EXE)
 └── main.cpp → Chamada de DLL

Procedimento de Restauração de Software (Inicialização/Reparo) para Dispositivos Android (Google Pixel)

Fri, 28 Feb 2025 01:20:41 +0900

Procedimento de Restauração para Dispositivos Android (Google Pixel)

Se o seu dispositivo Google Pixel sofrer problemas graves de sistema, como “reinicializações contínuas (bootloop)”, “travamento na tela do logotipo” ou “funcionamento extremamente instável”, você pode reparar (restaurar) o software do dispositivo de forma segura pelo navegador, usando a ferramenta oficial “Pixel Update and Software Repair” fornecida pelo Google.

Neste artigo, explicaremos detalhadamente os procedimentos específicos e os pontos de atenção.

1. Acessando a Ferramenta de Restauração

Primeiro, acesse a página oficial da ferramenta de reparo pelo navegador do seu PC (Windows ou Mac) (recomenda-se Google Chrome ou Microsoft Edge):

🔗 Site Oficial Pixel Update and Software Repair

※ Atenção ※ Quando você executa o processo de restauração, os dados no dispositivo (fotos, aplicativos, contatos, etc.) podem ser totalmente apagados (inicializados) . Se o dispositivo estiver operável, certifique-se de fazer um backup no Google Drive ou semelhante com antecedência.

2. Preparação Prévia para a Restauração

Para garantir que o processo ocorra sem problemas, prepare o seguinte:

Carga da Bateria Se a energia acabar no meio do processo, o dispositivo corre o risco de virar um peso de papel (quebrar completamente). Carregue pelo menos 50% ou, idealmente, o máximo possível.
Uso do Cabo USB Original Para garantir uma transferência de dados estável, é altamente recomendável usar o cabo USB-C original que veio com o dispositivo.
Instalação de Drivers (se necessário) Se estiver usando um PC com Windows, o dispositivo pode não ser reconhecido corretamente. Nesse caso, instale os Drivers USB do Google.

3. Passos Específicos de Restauração

Quando estiver pronto, siga as instruções na tela para prosseguir com a restauração.

Passo 1: Seleção da Operadora e Conexão do Dispositivo

Ao abrir o site, a tela de seleção de operadora (empresa de telefonia móvel) aparecerá primeiro. Se for desbloqueado ou sem operadora, selecione “Outro (Other)”, etc. Em seguida, conecte o PC e o dispositivo Pixel usando um cabo USB.

Passo 2: Colocar o Dispositivo no “Modo de Resgate (Modo Fastboot)”

Siga as instruções na tela. Com o dispositivo desligado, pressione e segure o botão de energia e o botão de diminuir volume ao mesmo tempo para iniciar o modo Fastboot (uma tela preta com o robô Android deitado).

Passo 3: Reconhecimento do Dispositivo no PC

Ao clicar no botão “Conectar dispositivo” no navegador, um pop-up abrirá mostrando o dispositivo Pixel conectado na lista. Selecione o dispositivo de destino e permita a conexão.

Passo 4: Download e Instalação do Software

Assim que o dispositivo for reconhecido, a versão ideal do Android OS (firmware) será selecionada automaticamente. Ao clicar em “Instalar”, o software será baixado para o PC e a gravação (flash) no dispositivo começará.

⚠️ Aviso: Durante esse processo, nunca desconecte o cabo USB ou desligue o PC.

Passo 5: Conclusão e Configuração Inicial

Quando a barra de progresso chegar a 100% e a mensagem “Concluído” aparecer, a restauração foi bem-sucedida. O dispositivo será reiniciado automaticamente e a tela de configuração inicial (a tela “Olá”), igual à de quando você o comprou, será exibida.

Resumo

A ferramenta de reparo oficial do Google Pixel é uma excelente ferramenta que permite gravar firmwares de forma segura apenas clicando no navegador, sem precisar executar comandos especiais (adb ou fastboot) diretamente.

Antes de levar seu dispositivo a uma loja por mau funcionamento, tentar este procedimento pode resolver o problema facilmente. Esperamos que este guia seja útil!

Trechos de código Python

Mon, 24 Feb 2025 18:21:14 +0900

Apresentação de códigos de exemplo usando a biblioteca padrão.

Baixar e exibir uma imagem

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


import urllib.request
import tempfile
import os
import webbrowser
import time

url = "https://www.aomori-ringo.or.jp/kids/wp-content/uploads/2021/11/apple.png"

try:
 with urllib.request.urlopen(url) as response:
 img_data = response.read()

 # Salvar em um arquivo temporário e exibir
 with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
 tmp.write(img_data)
 print(f"file://{tmp.name}")
 webbrowser.open(f"file://{tmp.name}")
 time.sleep(3)
except Exception as e:
 print(f"Ocorreu um erro: {e}")

finally:
 if 'tmp' in locals():
 os.unlink(tmp.name) # Excluir arquivo temporário

Chamar a API do ChatGPT pelo curl

Sat, 01 Feb 2025 17:15:34 +0900

Chamar a API do ChatGPT pelo curl

Presume-se que a chamada seja feita a partir do prompt de comando do Windows.

1
2

curl https://api.openai.com/v1/chat/completions -H "Content-Type: application/json" -H "Authorization: Bearer sk-proj-XXXXXXXXXXXXXXXXXXXX" -d "{""model"": ""gpt-3.5-turbo"",""messages"": [{""role"": ""system"", ""content"": ""Responda em dialeto Kansai.""}, {""role"": ""user"", ""content"": ""Insira a mensagem que deseja enviar aqui""}]}"

LoadIcon não precisa chamar DestroyIcon

Fri, 19 Apr 2024 01:55:17 +0900

Sobre a necessidade de chamar DestroyIcon

É necessário chamar DestroyIcon nos seguintes casos:

CreateIconFromResourceEx (se chamado sem a flag LR_SHARED)
CreateIconIndirect
CopyIcon

Quando criado pelas funções acima.

LoadIcon
LoadImage (se usar a flag LR_SHARED)
CopyImage (se usar a flag LR_COPYRETURNORG e o parâmetro hImage for um ícone compartilhado)
CreateIconFromResource
CreateIconFromResourceEx (se usar a flag LR_SHARED)

Ícones criados e carregados nos casos acima não devem chamar DestroyIcon.

Referência

Função DestroyIcon (winuser.h)

Coleção de Fontes para Programação

Sat, 30 Mar 2024 02:21:31 +0900

JetBrains Mono

É uma fonte de programação de código aberto fornecida pela JetBrains.

Download: https://www.jetbrains.com/ja-jp/lp/mono/

HackGen

Hakugen (HackGen) é uma fonte de programação que combina a fonte inglesa para programação Hack com a fonte GenJyuu Gothic, que é um derivado da Source Han Sans.

Download: https://github.com/yuru7/HackGen/releases

Ricty Diminished

Ricty Diminished é uma fonte irmã da Ricty, criada combinando Inconsolata e Circle M+ 1m com o script de geração da Ricty, em vez de Inconsolata e Migu 1M. Como não inclui glifos da fonte IPA Gothic, ela possui menos glifos de kanji disponíveis, mas em compensação pode ser distribuída sob a SIL Open Font License.

Download: https://rictyfonts.github.io/diminished

Cica

Caracteres alfanuméricos e símbolos usam Hack + DejaVu Sans Mono. Para outros caracteres, é uma fonte de programação que usa Rounded Mgen+.

Download: https://github.com/miiton/Cica/releases

Referência:

Migu

É uma fonte composta de M+ e IPA.

Download: https://itouhiro.github.io/mixfont-mplus-ipa/migu/

Osaka

É uma fonte que permite usar a fonte padrão do Mac OS, Osaka, no Windows.

Download: http://ifs.nog.cc/osakattf.hp.infoseek.co.jp/

PlemolJP

É uma fonte de programação que combina a fonte japonesa de código aberto IBM Plex Sans JP lançada pela IBM com a IBM Plex Mono da série Plex também da IBM.

Download: https://github.com/yuru7/PlemolJP/releases

Exemplo usando wxWidgets

Tue, 18 Apr 2023 00:18:22 +0900

O que é wxWidgets

wxWidgets é uma biblioteca GUI C++ que funciona em plataformas como Windows, Mac, Linux, Android, iOS, etc.

Instalação do wxWidgets

Abra https://www.wxwidgets.org/downloads/ e baixe o Windows Installer.
Execute wxMSW-3.2.2.1-Setup.exe para instalar.
Abra “C:\wxWidgets-3.2.2.1\build\msw\wx_vc17.sln” a partir da pasta instalada.
Após abrir wx_vc17.sln, selecione Build > Batch Build.
Pressione o botão Select All e, em seguida, o botão Rebuild.
Após a conclusão da compilação, feche o Visual Studio temporariamente.

Criação do projeto de exemplo

Abra o Visual Studio.
Selecione File > New > Project.
Selecione Windows Desktop Application (as guias são C++, Windows, Desktop).
Insira wxWidgetsSample em Project name.
Clique em Create.
Clique com o botão direito em wxWidgetsSample e selecione Properties.
Em Configuration Properties > C/C++ > Additional Include Directories, adicione C:\wxWidgets-3.2.2.1\include e C:\wxWidgets-3.2.2.1\include\msvc.
Em Configuration Properties > Linker > Additional Library Directories, adicione C:\wxWidgets-3.2.2.1\lib\vc_x64_lib.
Abra wxWidgetsSample.cpp e substitua pelo código abaixo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84


#pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")

#include <wx/wxprec.h>

#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif

class MyApp : public wxApp
{
public:
 virtual bool OnInit();
};

class MyFrame : public wxFrame
{
public:
 MyFrame();
private:
 void OnHello(wxCommandEvent& event);
 void OnExit(wxCommandEvent& event);
 void OnAbout(wxCommandEvent& event);
};

enum
{
 ID_Hello = 1
};

wxIMPLEMENT_APP(MyApp);

bool MyApp::OnInit()
{
 MyFrame* frame = new MyFrame();
 frame->Show(true);
 return true;
}

MyFrame::MyFrame()
 : wxFrame(NULL, wxID_ANY, "Hello World")
{
 wxMenu* menuFile = new wxMenu;
 menuFile->Append(ID_Hello, "&Hello...\tCtrl-H",
 "Help string shown in status bar for this menu item");
 menuFile->AppendSeparator();
 menuFile->Append(wxID_EXIT);
 wxMenu* menuHelp = new wxMenu;
 menuHelp->Append(wxID_ABOUT);
 wxMenuBar* menuBar = new wxMenuBar;
 menuBar->Append(menuFile, "&File");
 menuBar->Append(menuHelp, "&Help");
 SetMenuBar(menuBar);

 wxButton* button1 = new wxButton(this, ID_Hello, _("Hello"), wxPoint(20, 20), wxSize(100, 32));
 Connect(ID_Hello, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MyFrame::OnHello));

 wxButton* button2 = new wxButton(this, wxID_ABOUT, _("About"), wxPoint(20, 60), wxSize(100, 32));
 Connect(wxID_ABOUT, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MyFrame::OnAbout));

 wxButton* button3 = new wxButton(this, wxID_EXIT, _("Exit"), wxPoint(20, 100), wxSize(100, 32));
 Connect(wxID_EXIT, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MyFrame::OnExit));

 CreateStatusBar();
 SetStatusText("Welcome to wxWidgets!");
 Bind(wxEVT_MENU, &MyFrame::OnHello, this, ID_Hello);
 Bind(wxEVT_MENU, &MyFrame::OnAbout, this, wxID_ABOUT);
 Bind(wxEVT_MENU, &MyFrame::OnExit, this, wxID_EXIT);
}

void MyFrame::OnExit(wxCommandEvent& event)
{
 Close(true);
}

void MyFrame::OnAbout(wxCommandEvent& event)
{
 wxMessageBox("This is a wxWidgets' Hello world sample",
 "About Hello World", wxOK | wxICON_INFORMATION);
}

void MyFrame::OnHello(wxCommandEvent& event)
{
 wxLogMessage("Hello world from wxWidgets!");
}

Ao compilar e executar, uma janela como a abaixo será aberta.

Referências

O projeto de exemplo está disponível abaixo. wxWidgetsSample

É isso.

Como imprimir a hora atual no formato ISO 8601 em C++

Sat, 15 Apr 2023 19:35:27 +0900

Pré-requisitos

Padrão ISO C++ 20 (/std:c++20)

Código

1
2
3
4


#include <chrono>
#include <format>

std::string datetime = std::format("{:%FT%TZ}", system_clock::now());

É assim que você imprime a hora atual no formato ISO 8601 em C++.

Referências

std::format

[Por Linguagem] Resumo de Ambientes de Execução de Código Online

Sun, 09 Apr 2023 14:01:00 +0900

Python

Google Colaboratory

Google Colaboratory é um ambiente de execução de código Python online.

O uso de GPU também é possível.
Usando os notebooks do Colab, você pode escrever código executável e rich text (incluindo imagens, HTML, LaTeX, etc.) em um único documento.

É baseado no Jupyter Notebook.

Rust

Rust Playground

JavaScript

Javascript Playground

Java

paiza.IO Online Java compiler

Haskell

Haskell Playground

Swift

Online Swift Playground

C++

C++ 14

Outros

AWS Cloud9

Um ambiente de desenvolvimento integrado (IDE) online fornecido pela Amazon AWS. Ferramentas para mais de 40 linguagens de programação como Node.js, JavaScript, Python, PHP, Ruby, Go, C++, etc. já vêm empacotadas.

Visual Studio Code for the Web

Um ambiente de desenvolvimento online fornecido pela Microsoft. No entanto, linguagens que requerem compilação não podem ser executadas ou depuradas.

paiza.IO

Um ambiente de execução online que suporta 24 linguagens principais como C, C++, Java, Ruby, Python, PHP, Perl, etc.

CodePen

Um ambiente de execução online para HTML, CSS e JavaScript.

codeanywhere

Um IDE online. Permite compartilhamento de código e chat.

Como twittar usando a API do Twitter e o Google Colaboratory

Sat, 08 Apr 2023 18:48:32 +0900

O que você precisa

Twitter API
Twitter API SECRET
Twitter ACCESS TOKEN
Twitter ACCESS TOKEN SECRET
Conta do Google

Consulte o site de referência para saber como obter a API do Twitter.

Passos para twittar usando a API

Acesse https://colab.research.google.com/
Selecione “Arquivo” -> “Novo notebook”
Cole e execute o código abaixo (use seus próprios valores reais obtidos)

1
2
3
4


API_KEY = '9Smu2f2RoLqbVQHQq6n79Z2JW'
API_SECRET = 'uGVRIkLL2l8sRyPv2Lr4mXxXppnQF1isMoRnvktcXCtFgAK2R8'
ACCESS_TOKEN = '0367292979164670705-7hSErDoQbO6fkFtnn5UY0vqpvecy0O'
ACCESS_TOKEN_SECRET = 'pUv81U9GVzZirz5g4AxZPHAJ4GpSXnBo8GUcZ1egtjw9q'

Cole e execute o código abaixo

1

import tweepy

Cole e execute o código abaixo (API v1.1)

1
2
3
4


auth = tweepy.OAuthHandler(API_KEY, API_SECRET)
auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
api = tweepy.API(auth)
api.update_status("hello")

→ Um tweet dizendo hello será postado.

Cole e execute o código abaixo (API v2.0)

1
2


client = tweepy.Client(consumer_key=API_KEY, consumer_secret=API_SECRET, access_token=ACCESS_TOKEN, access_token_secret=ACCESS_TOKEN_SECRET)
client.create_tweet(text='hello v2')

→ Um tweet dizendo hello v2 será postado.

É isso.

Referência

Como compilar o OpenSSL no Windows

Fri, 07 Apr 2023 21:06:32 +0900

O que é o OpenSSL?

É uma biblioteca de código aberto que fornece o processamento necessário para realizar comunicação criptografada.

Para usá-lo a partir de um programa, como o código-fonte em C é publicado, você precisa compilá-lo para criar uma biblioteca.

Abaixo, apresentamos o procedimento de compilação.

Preparação do ambiente de compilação

Perl

Baixe o strawberry-perl-5.32.1.1-64bit.msi de https://strawberryperl.com/. A versão mais recente deve servir.
NASM

Baixe o 2.16.01/nasm-2.16.01-win64.zip em Download no site https://www.nasm.us/. A versão não-RC mais recente deve servir. Após a instalação, você precisa registrar a pasta onde o NASM está instalado na variável de ambiente PATH.
Visual Studio 2022 ou Build Tools for Visual Studio 2022

Instale o Visual Studio 2022 Community ou o Build Tools for Visual Studio 2022 a partir de https://visualstudio.microsoft.com/ja/downloads/.

Procedimento de compilação do OpenSSL no Windows

Baixe o openssl-3.1.0.tar.gz de https://www.openssl.org/source/ e extraia-o. Se não conseguir extrair, execute tar -xzf openssl-3.1.0.tar.gz no prompt de comando.
Inicie o prompt de comando com privilégios de administrador.
Abra a pasta extraída.
Execute o seguinte comando. *Altere a parte Community para corresponder à versão instalada do Visual Studio.

1

"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvarsall.bat" x64

Execute o seguinte comando:

1

perl Configure VC-WIN64A

Execute o seguinte comando (leva bastante tempo):

1

nmake

Execute o seguinte comando (leva bastante tempo):

1

nmake test

Execute o seguinte comando:

1

nmake install

Se for bem-sucedido, o OpenSSL será instalado em C:\Program Files\OpenSSL.

Isso é tudo.

Referências

https://ja.wikipedia.org/wiki/OpenSSL

Como criar apresentações com HTML (reveal.js)

Thu, 06 Apr 2023 23:23:46 +0900

Como criar apresentações com HTML

reveal.js é uma ferramenta de criação de apresentações usando HTML e Markdown, que possui as seguintes funções:

Várias funções de apresentação, como fórmulas matemáticas, animações e operações de deslizar
Temas e layouts personalizáveis
Funções de navegação suportadas por vários dispositivos, como mouse, teclado e touchpad
Funções avançadas, como reprodução automática de slides e vídeos incorporados
Pode ser exportado no formato PDF

Com esses recursos, os usuários podem criar facilmente apresentações interativas e atraentes.

Instalação e uso do reveal.js

A maneira mais fácil de usá-lo é baixar e extrair o ZIP inteiro da página a seguir.

Abra https://revealjs.com/installation e baixe o master.zip no link
Abra o arquivo index.html na pasta extraída em um navegador
Reescreva o index.html para criar sua própria apresentação

※ Como o código HTML de demonstração está escrito em demo.html, você pode usá-lo como referência.

Como utilizar

As apresentações que você criar podem ser publicadas como páginas da web ou exportadas como PDFs. Além disso, como a fonte da apresentação é texto, é fácil gerenciá-la com um sistema de controle de versão.

Também parece ser possível criar materiais de apresentação no formato Markdown.

Referências

Como gerar imagens de ilustração usando IA (Stable Diffusion)

Thu, 06 Apr 2023 00:43:19 +0900

O que é o Stable diffusion

O Stable diffusion é uma IA desenvolvida por uma equipe de pesquisa da Universidade de Munique, na Alemanha, que gera imagens a partir de informações de texto fornecidas. Ao treinar com várias imagens, ele pode gerar uma variedade de imagens, desde fotografias até ilustrações.

Desta vez, apresentarei como gerar imagens de ilustração usando os dados pré-treinados do Stable diffusion.

O que você vai precisar

Conta do Google

Apenas isso

Procedimento de geração

Abra https://colab.research.google.com
Selecione Arquivo no canto superior esquerdo e depois Novo notebook
Selecione Editar e depois Configurações do notebook
Altere o Acelerador de hardware para GPU
Cole o código abaixo e execute

1

!pip install diffusers==0.8.0 transformers

Cole o código abaixo e execute

1

from diffusers import StableDiffusionPipeline

Cole o código abaixo e execute

1
2


pipe = StableDiffusionPipeline.from_pretrained("gsdf/Counterfeit-V2.5")
pipe.to("cuda")

Cole o código abaixo e execute

1
2
3
4
5


prompt = "((masterpiece,best quality)),1girl, solo, animal ears, rabbit, barefoot, knees up, dress, sitting, rabbit ears, short sleeves, looking at viewer, grass, short hair, smile, white hair, puffy sleeves, outdoors, puffy short sleeves, bangs, on ground, full body, animal, white dress, sunlight, brown eyes, dappled sunlight, day, depth of field"
n_prompt = "EasyNegative, extra fingers,fewer fingers"

image = pipe(prompt, negative_prompt = n_prompt).images[0]
image

O Prompt usado aqui é baseado no Prompt de https://huggingface.co/gsdf/Counterfeit-V2.5.

Resultados gerados (alguns)

Referências

Como atualizar o rustc

Sat, 18 Mar 2023 10:27:02 +0900

Como atualizar o rustc

Basta executar a seguinte linha de comando.

1

rustup update

Referência de saída

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


rustup update
info: syncing channel updates for 'stable-x86_64-pc-windows-msvc'
warning: Signature verification failed for 'https://static.rust-lang.org/dist/channel-rust-stable.toml'
info: latest update on 2023-03-09, rust version 1.68.0 (2c8cc3432 2023-03-06)
info: downloading component 'rust-src'
info: downloading component 'cargo'
info: downloading component 'clippy'
info: downloading component 'rust-docs'
info: downloading component 'rust-std'
info: downloading component 'rustc'
 63.9 MiB / 63.9 MiB (100 %) 37.5 MiB/s in 1s ETA: 0s
info: downloading component 'rustfmt'
info: removing previous version of component 'rust-src'
info: removing previous version of component 'cargo'
info: removing previous version of component 'clippy'
info: removing previous version of component 'rust-docs'
info: removing previous version of component 'rust-std'
info: removing previous version of component 'rustc'
info: removing previous version of component 'rustfmt'
info: installing component 'rust-src'
info: installing component 'cargo'
info: installing component 'clippy'
info: installing component 'rust-docs'
 19.4 MiB / 19.4 MiB (100 %) 2.4 MiB/s in 6s ETA: 0s
info: installing component 'rust-std'
 27.6 MiB / 27.6 MiB (100 %) 12.7 MiB/s in 2s ETA: 0s
info: installing component 'rustc'
 63.9 MiB / 63.9 MiB (100 %) 13.8 MiB/s in 4s ETA: 0s
info: installing component 'rustfmt'
info: checking for self-updates
info: downloading self-update

 stable-x86_64-pc-windows-msvc updated - rustc 1.68.0 (2c8cc3432 2023-03-06) (from rustc 1.64.0 (a55dd71d5 2022-09-19))

info: cleaning up downloads & tmp directories

Características do Rust

Mon, 03 Oct 2022 22:47:20 +0900

Características do Rust

Uma linguagem de programação de código aberto relativamente nova desenvolvida pela Mozilla
Linguagem rápida, sem coleta de lixo (garbage collection), especializada em programação de sistemas
Garante a segurança de memória com mecanismos únicos de propriedade (ownership) e empréstimo (borrowing) como especificações da linguagem
Funciona em multiplataformas
Possui o excelente gerenciador de pacotes Cargo como padrão

Exibir uma janela simples em Rust

Sat, 01 Oct 2022 19:08:58 +0900

Exibir uma janela simples em Rust

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[package]
name = "win"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies.winapi]
version = "0.3"
features = ["winuser"]

O código-fonte está abaixo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78


#![windows_subsystem = "windows"]
use winapi::{
 um::{
 winuser::{RegisterClassW, WNDCLASSW, CS_HREDRAW, CS_VREDRAW,
 LoadIconW, IDI_APPLICATION, LoadCursorW, IDC_ARROW,
 CreateWindowExW, ShowWindow, SW_NORMAL, UpdateWindow,
 GetMessageW, TranslateMessage, DispatchMessageW, MSG,
 WM_DESTROY, PostQuitMessage, DefWindowProcW, WS_OVERLAPPEDWINDOW,
 CW_USEDEFAULT},
 wingdi::{GetStockObject, WHITE_BRUSH},
 },
 shared::{
 windef::{HWND, HBRUSH},
 minwindef::{UINT, WPARAM, LPARAM, LRESULT},
 },
};
use std::ptr;
use std::mem;

fn main() {
 unsafe {
 let class_name = encode("my_window_class_name");
 if !register_wndclass(&class_name) {
 return;
 }
 let hwnd = create_window(&class_name);
 if hwnd.is_null() {
 return;
 }
 ShowWindow(hwnd, SW_NORMAL);
 UpdateWindow(hwnd);
 let mut msg = mem::uninitialized::<MSG>();
 loop {
 if GetMessageW(&mut msg, ptr::null_mut(), 0, 0) == 0 {
 return;
 }
 TranslateMessage(&mut msg);
 DispatchMessageW(&mut msg);
 }
 }
}

fn encode(source: &str) -> Vec<u16> {
 source.encode_utf16().chain(Some(0)).collect()
}

unsafe fn register_wndclass(class_name: &[u16]) -> bool {
 let mut winc = mem::zeroed::<WNDCLASSW>();
 winc.style = CS_HREDRAW | CS_VREDRAW;
 winc.lpfnWndProc = Some(win_proc);
 winc.hIcon = LoadIconW(ptr::null_mut(), IDI_APPLICATION);
 winc.hCursor = LoadCursorW(ptr::null_mut(), IDC_ARROW);
 winc.hbrBackground = GetStockObject(WHITE_BRUSH as i32) as HBRUSH;
 winc.lpszClassName = class_name.as_ptr();
 RegisterClassW(&winc) > 0
}

unsafe fn create_window(class_name: &[u16]) -> HWND {
 CreateWindowExW(
 0,
 class_name.as_ptr(),
 encode("Hello, World!").as_ptr(),
 WS_OVERLAPPEDWINDOW,
 CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
 ptr::null_mut(),
 ptr::null_mut(),
 ptr::null_mut(),
 ptr::null_mut(),
 )
}

unsafe extern "system" fn win_proc(hwnd: HWND, msg: UINT, w_param: WPARAM, l_param: LPARAM) -> LRESULT {
 match msg {
 WM_DESTROY => PostQuitMessage(0),
 _ => return DefWindowProcW(hwnd, msg, w_param, l_param),
 };
 0
}

Referências

Programação Windows em Rust - CreateWindow

Escrevendo testes em Rust

Sat, 01 Oct 2022 02:00:59 +0900

Para escrever um teste em Rust, adicione o atributo #[test] uma linha acima da definição da função de teste.

1
2
3
4
5
6
7
8


fn plus(a:i32,b:i32)->i32 {
 a+b
}

#[test]
fn plus_test() {
 assert_eq!(plus(1, 1), 2);
}

O código de teste pode ser executado com cargo test. Quando o teste for bem-sucedido, ele exibirá ok. Se falhar, exibirá FAILED.

Caso de sucesso

1
2
3
4
5
6
7
8
9


C:\Users\admin\Desktop\test1>cargo test
 Compiling test1 v0.1.0 (C:\Users\admin\Desktop\test1)
 Finished test [unoptimized + debuginfo] target(s) in 0.35s
 Running unittests src\main.rs (target\debug\deps\test1-be5d3118bc52cb3a.exe)

running 1 test
test plus_test ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Caso de falha

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


C:\Users\admin\Desktop\test1>cargo test
 Compiling test1 v0.1.0 (C:\Users\admin\Desktop\test1)
 Finished test [unoptimized + debuginfo] target(s) in 0.33s
 Running unittests src\main.rs (target\debug\deps\test1-be5d3118bc52cb3a.exe)

running 1 test
test plus_test ... FAILED

failures:

---- plus_test stdout ----
thread 'plus_test' panicked at 'assertion failed: `(left == right)`
 left: `2`,
 right: `3`', src\main.rs:7:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
 plus_test

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass '--bin test1'

Exibir um MessageBox em Rust

Fri, 30 Sep 2022 23:54:31 +0900

Você pode exibir um MessageBox em Rust seguindo os passos abaixo.

Instale o Rust. Consulte Como começar com Rust
Execute cargo new --bin MessageBox no prompt de comando.
Vá para o diretório MessageBox.
Abra Cargo.toml e modifique-o conforme abaixo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[package]
name = "hello_world"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
winapi = "0.2.7"
user32-sys = "0.2.0"

Abra src\main.rs e modifique-o conforme abaixo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


extern crate user32;
extern crate winapi;

use std::ffi::CString;
use user32::MessageBoxA;
use winapi::winuser::{MB_OK, MB_ICONINFORMATION};

fn main() {
 let lp_text = CString::new("Hello, world!").unwrap();
 let lp_caption = CString::new("MessageBox Example").unwrap();

 unsafe {
 MessageBoxA(
 std::ptr::null_mut(),
 lp_text.as_ptr(),
 lp_caption.as_ptr(),
 MB_OK | MB_ICONINFORMATION
 );
 }
}

Execute cargo run no prompt de comando.
Se você deseja fazer uma compilação de release, execute cargo build --release.

Referência

Hello World MesssageBox example in Rust

Enumeração de Títulos de Janelas

Tue, 20 Sep 2022 17:03:15 +0900

Enumeração de Títulos de Janelas

Aqui está como enumerar os títulos das janelas abertas atualmente usando o PowerShell.

1

Get-Process|where{$_.mainWindowTItle}|Select-Object MainWindowTitle

Exemplo de saída

1
2
3
4
5
6
7
8
9


MainWindowTitle
---------------
Windows PowerShell
Internet Explorer
Sem título - Paint
Sem título - Bloco de Notas
Gerenciador de Tarefas
Experiência de Entrada do Windows
Documento - WordPad

Excluir .DS_Store em lote com PowerShell

Mon, 12 Sep 2022 10:11:42 +0900

Mova o diretório atual para a pasta de destino e execute o seguinte comando para excluir em lote os arquivos .DS_Store, incluindo aqueles em subpastas.

1

Get-ChildItem . -include '.DS_Store' -Recurse -Force | Remove-Item -Force

Como instalar o Go

Sat, 10 Sep 2022 00:48:17 +0900

Introdução

Go é uma linguagem de programação relativamente nova lançada pelo Google em 2009. O compilador, ferramentas e bibliotecas do Go são de código aberto. Além disso, Go é uma linguagem estaticamente tipada como C e Java, mas não usa ponteiros da mesma forma que a linguagem C.

Método de instalação

Instalar o Go

Instaladores para cada plataforma estão publicados no site acima.

Siga as telas para prosseguir com a instalação.

Instalação concluída. É simples, não é?

Primeiro programa

Salve o seguinte programa como hello.go.

1
2
3
4
5
6
7


package main

import "fmt"

func main() {
 fmt.Printf("Hello World\n")
}

Ao executar go run hello.go no prompt de comando ou terminal, será exibido Hello, world!.

Ao compilar, executar go build hello.go irá gerar hello.exe. Executar hello.exe exibirá Hello, world!.

Você também pode executar código na página da Web

https://go.dev/play/

Documentação Japonesa

http://go.shibu.jp/

As explicações necessárias para aprender Go estão reunidas no link acima (versão traduzida em japonês). A tecnologia relacionada ao Go é tão aberta e rica que quase não há necessidade de comprar textos em papel.

Então, aproveite sua vida com Go!

Enumerando Números Primos em Rust

Fri, 09 Sep 2022 07:08:49 +0900

Escrevi um programa para enumerar números primos em Rust.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


fn main() {
 let max = 1000;
 let mut primes = vec![2];
 let mut n = 3;
 loop {
 let mut is_prime = true;
 for p in &primes {
 if n % p == 0 {
 is_prime = false;
 break;
 }
 }
 if is_prime {
 primes.push(n);
 }
 n += 2;
 if n > max {
 break;
 }
 }
 for p in &primes {
 println!("{}", p);
 }
}

Como começar com Rust

Tue, 06 Sep 2022 00:12:36 +0900

Introdução

Rust é uma linguagem de programação relativamente nova que permite escrever módulos rápidos e eficientes em memória com uma sintaxe moderna. É compatível com várias plataformas e também é usada no mundo do WebAssembly e em sistemas embarcados. De forma notável, foi adotada pelo Firefox, DropBox e Cloudflare.

Também está atraindo atenção como uma alternativa ao C++.

Como instalar

Instalar o Rust

O site acima fornece instruções de instalação para cada plataforma.

Primeiro programa

Salve o seguinte programa como main.rs.

1
2
3


fn main() {
 println!("Hello, world!");
}

Ao executar rustc main.rs no prompt de comando ou terminal, ele será compilado. Executar ./main (ou main.exe no Windows) exibirá Hello, world!.

Documentação em Japonês

The Rust Programming Language Edição Japonesa

As explicações necessárias para aprender Rust estão compiladas no link acima (versão traduzida para o japonês). É tão abrangente que você não precisa comprar um livro sobre Rust.

Se você quiser experimentar na Web

Se você quiser experimentá-lo na Web sem instalar o compilador, pode usar The Rust Playground. Após inserir o código e clicar no botão “Run”, ele será compilado e executado na Web.

Programação on kenji.blog

Como resolver quando você não consegue cancelar o Google One (Gemini)

[Aviso] Serei cobrado quando o teste gratuito do Gemini terminar? Resumo de como cancelar

O que acontece quando o teste gratuito termina?

Se você cancelar, não será cobrado, mas…

O método de cancelamento correto está aqui!

Resumo

Como remover em lote metadados (informações pessoais) do Excel, Word, etc. usando o PowerShell

“Como remover em lote metadados (informações pessoais) do Excel, Word, etc. usando o PowerShell”

1. Remover os metadados de um único arquivo do Excel

2. Processar todos os arquivos do Excel em uma pasta em lote

3. Remover metadados de outros arquivos do Office (Word / PowerPoint)

Para o Word

Para o PowerPoint

Conclusão

Passos para chamar o TinyLLaMA a partir de C++ (usando llama.cpp)

✅ Configuração do TinyLLaMA × C++ (usando llama.cpp)

🔧 Passo 1: Preparar o llama.cpp

1-1. Ambiente necessário (Mínimo)

1-2. Obter e compilar llama.cpp

📦 Passo 2: Baixar e converter o modelo TinyLLaMA

2-1. Obter o modelo original do HuggingFace

2-2. Converter para formato GGUF (para llama.cpp)

2-3. Quantização do modelo (redução de tamanho)

🧪 Passo 3: Chamar o modelo a partir do C++ (Exemplo de código)

3-1. Código C++ simples (Inferência)

🧱 Passo 4: Como compilar (Exemplo)

✅ Exemplo de estrutura dos artefactos (Organização)

🧠 Notas adicionais para aplicação em casos de uso

📌 Resumo

Vantagens e Desvantagens de Criar Programas com Win32API + C++

O Fascínio e os Desafios de Desenvolver com Win32API + C++

Vantagens

Execução Nativa Ultrarrápida

Alta Flexibilidade e Liberdade

Fácil de Distribuir sem Necessidade de Runtime

Pode Criar Aplicativos Leves

Controle Avançado em Nível de SO Possível

Desvantagens

Baixa Eficiência de Desenvolvimento

Fácil de Reduzir a Manutenibilidade

Difícil de Suportar UI Moderna

Não Suporta Multiplataforma

Custo de Aprendizado Extremamente Alto

Usos Adequados

Usos Inadequados

Resumo da Avaliação

Conclusão

FizzBuzz

Afinal, o que é FizzBuzz?

É verdade que “se você não consegue escrever FizzBuzz, você é um fracasso como programador”?

Não é sobre poder ou não, mas se você tem o “estado” para poder

A armadilha do conselho comum de “Basta treinar e ficará tudo bem”

Dito isto, o FizzBuzz ainda é uma boa pergunta

Por tanto

Torre de Hanói

Torre de Hanói

O que é a Torre de Hanói?

Vamos resolver a Torre de Hanói com Python

Quanto tempo leva para mover 64 discos?

Resumo

Passos para Executar o PowerShell a partir de C++ via DLL C++/CLI

🎯 Passos para Executar o PowerShell a partir de C++ via DLL C++/CLI (Visual Studio 2022 / C++)

✅ Visão Geral da Arquitetura

🔹 ① DLL Wrapper CLI (C++/CLI)

🔹 ② Chamador Nativo C++

🔧 Passo 1: Criando o Projeto DLL Wrapper CLI

1. Criar o Projeto

2. Adicionar o Pacote NuGet

3. Implementação do Código CLI

PowerShellWrapper.h

PowerShellWrapper.cpp

🔧 Passo 2: Chamando a partir do C++ Nativo

1. Criar o Projeto de Aplicativo de Console C++

2. Adicionar Referência

3. Código de Execução (main.cpp)

💡 Informações Adicionais (IDL / TLB / Registro COM)

✅ Estrutura Final

Procedimento de Restauração de Software (Inicialização/Reparo) para Dispositivos Android (Google Pixel)

Procedimento de Restauração para Dispositivos Android (Google Pixel)

✅ Configuração do TinyLLaMA × C++ (usando `llama.cpp`)

2-2. Converter para formato GGUF (para `llama.cpp`)