Bimetal

O meu não precisa ativar. Ele reconhece automaticamente. Eu acho que você tem razão porque, quando o celular chegou perto de 100%, o powerbank mudou de 9 V para 5 V. Vou fazer o teste com a bateria zerada.

Funcionou com o cabo que veio mas não no modo turbo. O cabo que vem com o celular é separável do carregador e eu testei com ele também e não carregou no modo turbo. Testei nas outras portas também e tive o mesmo resultado. Esse powerbank em específico mostra a tensão de saída e a tensão fica em 9 V, mas meu telefone tem suporte para 20 V e 3,25 A.

Um powerbank é um carregador portátil.

Comprei para carregar meu celular quando eu não puder usar o carregador.

Sim. Quando eu coloco meu celular no carregador ele carrega no modo turbo.

Comprei na loja online deles. Então seria esse o problema? Vou procurar um cabo turbo de boa qualidade e testar então.

Então, veio um cabo junto com o powerbank com suporte pra 100 W e eu já tentei usar o cabo do meu carregador e também não funciona.

Eu comprei um powerbank da Baseus, modelo BS-30KP365, com saída de 65 W para usar num POCO X4 GT que tem suporte para essa potência, mas ele não está funcionando no modo turbo com o meu celular, somente no modo normal. Seria esse um problema de incompatibilidade?

Olá pessoal. Eu venho tentando usar o algoritmo set_union porém sem sucesso. As referências dizem que o quinto parâmetro pede um output iterator só que no meu código o parâmetro não está sendo aceito e eu não consigo descobrir o por quê. #include <iostream> #include <set> #include <string> #include <iterator> #include <algorithm> int main() { const char* let1[] = { "1", "2", "3", "4", "5", "6" }; const char* let2[] = { "1", "3", "5", "7", "8", "9" }; std::set<std::string> set1(let1, let1 + 6), set2(let2, let2 + 6), set3; set3.get_allocator().allocate(10); std::cout << "Set1: "; std::copy(set1.begin(), set1.end(), std::ostream_iterator<std::string, char, std::char_traits<char>>(std::cout, " ")); std::cout << std::endl << std::endl; std::cout << "Set2: "; std::copy(set2.begin(), set2.end(), std::ostream_iterator<std::string, char, std::char_traits<char>>(std::cout, " ")); std::cout << std::endl << std::endl; std::cout << "Union: "; std::set_union(set1.begin(), set1.end(), set2.begin(), set2.end(), set3.begin()); std::copy(set3.begin(), set3.end(), std::ostream_iterator<std::string, char, std::char_traits<char>>(std::cout, " ")); std::cout << std::endl << std::endl; return EXIT_SUCCESS; } Alguém sabe me dizer por que isso está acontecendo? Quem puder me esclarecer isso eu agradeço.

Olá @arfneto. No caso poderia ser qualquer aplicação simples. Seria só mesmo pra eu saber como se implementa isso.

Olá pessoal. Eu gostaria de saber como eu poderia criar manipuladores parametrizados, tal como acontece com setfill ou setw. Eu sei que pra este caso deve-se utilizar duas funções sobrecarregadas, uma que receba uma referência de ostream ou istream e o tipo que se quer utilizar e uma outra função genérica que receba o tipo e chame a primeira função, mas nada do que eu consigo achar na internet ajuda.

Agora entendi. Então este tipo de função de sobrecarga faz com que, na atribuição, haja uma espécie de "casting" implícito do tipo da classe para o tipo atribuído. Embora eu tivesse o mesmo efeito prático se eu sobrecarregasse o operador de atribuição(=). Obrigado, pessoal.

@João Vitor Sacramento Rocha Como assim o tipo é da classe Valor? Como isso foi definido? E o que eu tenho que estudar exatamente pra entender isso? POO abrange muita coisa.

Olá pessoal. Eu me deparei com um tipo de “sobrecarga de operador”(ou talvez uma sobrecarga de um tipo primitivo) que foge da sintaxe comum(tipo operator símbolo(parâmetro)). Vou deixar um exemplo abaixo pra ficar mais claro. #include <iostream> class Valor { private: int valor; public: explicit Valor(int valor); operator int*(); }; Valor::Valor(int valor) { this->valor = valor; } Valor::operator int*() { int* val = new int; *val = valor; return val; } int main() { Valor dois(2); int* val; val = dois; std::cout << "Valor: " << *val; } As minhas dúvidas são as seguintes: esta é uma sobrecarga de um tipo primitivo? Como é possível uma função de sobrecarga sem um tipo de retorno retornar um tipo? Como foi possível atribuir o objeto ao tipo inteiro sem a sobrecarga do operador de atribuição(=)? É necessário este tipo de sobrecarga retornar um ponteiro sempre? Como funciona este tipo de sobrecarga exatamente? Achei muito interessante esse tipo de sobrecarga e eu não a conhecia. Quem puder me esclarecer eu agradeço.

Desconsiderem a última pergunta. Acho que eu não pensei direito antes. Acabei entendendo. Obrigado pela atenção.