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.

Pessoal, desculpem a demora na resposta. Meu tempo ultimamente tá curto e com um assunto extremamente difícil de se aprender eu acabei demorando um pouco. Então é o seguinte: até onde eu entendi o que o cara do vídeo falou, quando uma classe tem uma função virtual, é adicionado um ponteiro(que ele chamou de vptr) na classe que aponta para uma “tabela virtual”(que ele chamou de v-table) onde, nessa “tabela virtual”, existem os endereços das respectivas funções virtuais da classe. O programa do @arfneto ajudou a elucidar as funções virtuais com o uso do vetor de ponteiros pra função(o que seria uma simulação da “tabela virtual”), mas na prática eu ainda não entendi como isso funciona. Por exemplo: eu não entendi direito como esse vptr é acessado em uma chamada de função virtual. É de maneira implícita? E como o programa consegue saber qual função chamar na “tabela virtual”?

Olá pessoal. Quando estava estudando herança me deparei com a palavra-chave virtual. Aparentemente esta palavra-chave corrige um erro de ambiguidade de funções e dados membro quando múltiplas cópias de uma classe base são herdadas em uma classe derivada. Eu até aprendi como utilizar, mas não me ensinaram como funciona. Eu acredito que esta palavra-chave adicione algum ponteiro a classe que permita que a classe derivada herde não uma cópia mas uma referência da classe base. Se alguém puder dizer como esta palavra-chave funciona exatamente eu agradeço.

@arfneto Entendi. Obrigado.

Então @arfneto, eu ainda não consegui entender. Mas eu não poderia declarar a função de sobrecarga dentro da classe? Desse modo eu não teria acesso ao conteúdo da classe? A ideia da sobrecarga desse operador é para a imprimir dados de um objeto direto por cout.

Olá pessoal. Eu estava estudando sobre a sobrecarga do operador de extração(<<) e vi que pra fazer a sobrecarga deve-se usar obrigatoriamente uma função amiga na classe pra onde o operador sobrecarregado será usado. Por que isso é obrigatório? Por que eu não poderia declarar a função dentro da classe?

Oi @arfneto. Eu sei que, por exemplo: a->b é igual a (*a).b, mas eu não sei como isso funciona de forma mais interna. Como eu não sei como funciona o operador, eu não tenho como saber como funciona a sobrecarga. Eu disse também que eu não entendi o propósito da sobrecarga deste operador porque, de acordo com o exemplo que eu coloquei ai, ele simplesmente me permite fazer algo que eu já posso fazer com o operador ponto.

Olá pessoal. Eu vi um exemplo simples de um código(vou colocar abaixo) que sobrecarrega o operador -> e não consegui entender a "mecânica" do funcionamento. Na verdade eu também não sei como este operador funciona sem estar sobrecarregado, eu só sei usar ele. Também não consegui entender qual é o propósito de se sobrecarregar este operador, visto que ele sobrecarregado só serve para substituir o operador ponto. #include <iostream> class Seta { public: int i; Seta* operator->() { return this; } }; int main() { Seta obj; obj->i = 10; std::cout << "Com ponto: " << obj.i << std::endl << "Com seta: " << obj->i; }

Olá pessoal. Eu vinha estudando sobrecarga de operadores e me deparei com o int que é passado como argumento formal à função de sobrecarga do operador de incremento sufixal. Eu gostaria de saber o porquê da obrigatoriedade do tipo int, já que nas sobrecargas de outros operadores o tipo do parâmetro obedece o tipo do operando?

@Flávio Pedroza Entendi. Obrigado.

Olá pessoal. Eu gostaria de saber o porquê de uma função-membro estática só poder acessar outros membros estáticos em uma classe.