arfneto

Esse comando faz a mesma coisa que você faz na interface grafica ao remover os protocolos ipv4 e ipv6 e se você não tinha mudado nada ele não vai fazer nada. O que tem lá naquelas chaves é apenas o modo de endereçamento e o endereço se for usar endereço fixo. Isso inclui os endereços de DNS e WINS, e o endereço alternativo para o caso do servidor DHCP não responder em tempo. Como qualquer um que tenha problemas com isso vai no primeiro minuto chegar exatamente essas configurações para a placa de rede, esse comando não serve em geral para NADA. Embora o help diga PS C:\Users\CDH> netsh int ip reset /? Usage: reset Parameters: none Remarks: Removes all user configured settings. Restarting computer is required before the default settings to be effect. PS C:\Users\CDH> Essas configurações passam a valer assim que o usuário clica no OK na inerface gráfica, então pode ser melhor usar o mouse do que o teclado nesse caso, economizando um reset. Limpe a cache do DNS: ipconfig /flushdns. Verifique as definições de rede e DNS nas definições do Windows. Certifique-se de que está a utilizar o DNS predefinido se não tiver a certeza da escolha. Sempre vejo essa recomendação, porque vem embutida naqueles scripts com vários comandos supostamente salvadores que vemos na internet. Entenda que o cache de DNS fica em memória e as entradas no cache tem um TTL e expiram em acho que 2 minutos. Não ajuda muito limpar isso a menos que tenha uma suspeita de fraude no momento. Apesar de muitas recomendações diferentes, se usa um provedor bem estabelecido e que tem na rede dele servidores DNS deve usar esses porque a latência é muito menor. Na dúvida faça o simples e meça usando algo como o DNSBench de tempos em tempos. E entenda que DNS não vai deixar a rede lenta. Trata-se da simples tradução de nomes e depois do primeiro acesso estarão em cache em sua máquina, talvez no seu roteador, e provavelmente em caches intermediários e nem vão chegar aos servidores que especificar

serviço de DNS não vai proporcionar um acesso melhor a internet. DNS apenas converte nomes para endereços e vice-versa, usando uma conexão na porta 53, em geral via UDP e em alguns casos via TCP. DNS nada tem a ver com ping e pouco ou nada a ver com jogos ou atividades específicas. Em geral, para provedores com alguma estrutura, o melhor servidor de DNS é o que está DENTRO da própria rede do provedor. É fácil de entender: a latência é muito menor se o servidor já estiver na rede do provedor. Por isso por exemplo servidores como 181.213.132.2 para a Claro e 200.204.0.10 para a VIVO costumam ter performance muito melhor que os do Google en 8.8.8.8 ou CloudFare em 1.1.1.1. O normal é simplesmente medir e a ferramenta mais comum é o DNSBench da GIBSON, e o resulado mais comum é o que acabei de dizer, pela razão que expliquei. Pouca chance disso ter algo a ver com DNS. Mais ainda, entenda que seu roteador pode ter cache de DNS, e seu computador certamente tem, de modo que suas requisiçÕes de endereço só vão parar no servidor na primeira vez em cada sessão. Depois disso ficam armazenadas em cache. Em Windows pode ver isso usando ipconfig /DisplayDNS. Essas opções que povoam a internet com comandos para limpar cache de DNS e de netbios e coisas assim são folclóricas. Isso é irrelevante. O cache fica em memória. Basta reiniciar o micro ou reabrir sessão. Mesmo hibernação preserva algumas dessas coisas, mas os registros em cache tem TTL, expiram em minutos, de modo que se demorar para religar a maquina de hibernação ou suspensão também vai zerar o cache. Notebooks não são formatados, apenas discos. O componente de rede em apenas 4 componentes básicos e cada placa de rede tem um driver. Para redefinir isso não precisa formatar o disco nem reinstalar o sistema. Exclua a placa no gerenciador de disposistivos e o driver se vai. Quanto ao stack tcp/ip em Windows tem o cliente para redes microsoft, o compartilhamento de arquivos, os protocolos v4 e v6, e alguns componentes que são instalados a partir desses. Basta excluir tudo e instalar de novo. Em geral tudo no automático. Há pouca razão para um usuário comum mudar alguma dessas configurações. Quando ao banco de dados, espero que tenha a rotina de manter backup de seus dados, de todo modo. Dois ou tres conjuntos, em locais separados

Não, MinGW não é um compilador. A distribuição inclui entre outras coisas um compilador gcc, mas pode usar MinGw e ter várias versões de gcc coexistindo na mesma máquina. E também pode instalar o MinGW sem o compilador, caso tenha um ou vários gcc já rodando em sua máquina. Considere: Direto de https://winlibs.com/ o lar do MinGW Não há formalização disso. Pode usar mais e mais "dimensões" enquanto houver memória, se tiver algum sentido em milhares de dimensões. E para testar pode usar, mesmo no Windows, binutils e make e um programa C para ir aumentando as dimensões. Use alocação dinâmica e crie do exato tamanho que precisa... É o simples e versátil.

Não existe de fato esse lance de matriz multidimensional em C ou C++, como tem em FORTRAN. Só existe escalar e vetor. Mas tem vetor de vetor, vetor de vetor de vetor e tal... Na prática quer dizer que [1] Sim, pode usar quantas "dimensões" quiser, e estarão lá alinhadas por linha a partir do endereço de início. char vetor[3][4] = {0}; declara vetor como um vetor com tres vetores de 4 char, por exemplo. [2] O limite vai depender de como cria isso. Se usa isso estático vai depender do tamanho de stack que seu programa está configurado para aceitar. Se vai alocar dinâmicamente o limite é a memória disponível em tempo de execução. MinGW não é um compilador. Nada tem a ver com isso. Seu compilador deve ser o gcc em Windows. Poste o código completo. Seu problema não está em nenhuma limitação do compilador ou da linguagem. Apenas acompanhe o tamanho de fato que está alocando. POSTE o código completo ou não há muito em que ajudar...

Como parece ter resolvido seu problema, vou mostrar como continuar o programa que mostrei 4X e ter algo que vai do arquivo até o propósito de criar um vetor na memória com uma linha para cada linha do arquivo. Acho que é legal ter algo assim no forum, que funcione para qualquer propósito, com fonte e exemplo e saída. Escrevendo em torno dos dados: Eis a saída que vai ser usada aqui no exemplo typedef struct { size_t incr; // tamanho do incremento size_t limit; // tamanho disponivel para uso size_t size; // tamanho em uso agora char** line; // as linhas } Array2D; Nada mais. É como em todo programa C, como expliquei antes: int main(int argc, char** argv); Todo programa C recebe uma lista de argumentos, e cada linha do arquivo de entrada pode ser vista assim. E os outros parâmetros? Simples. Não faz muito sentido ficar alocando memória a cada linha que o programa lê. E também não dá pra imaginar um tamanho máximo e alocar como 500 linhas com 80 colunas sempre, até uma linha ter mais de 80 colunas ou um arquivo ter mais que 500 linhas. Então tem os valores para o tamanho inicial, para cada incremento e para o tamanho total. E na criação o usuário pode escolher os valores que achar melhor. Encapsulamento e o princípio de única responsabilidade Esses são nomes chiques para uma coisa simples: todas as operações feitas com esse tal Array2D são feitas através de um ponteiro para a estrutura toda (encapsulamento) e dentro dela tem tudo o que importa. E cada função que opera com o Array como um todo faz uma e uma só coisa. Esse é o princípio de única responsabilidade, SRP. As funções em um exemplo mínimo Array2D* create_blk(size_t size, size_t incremento); Array2D* delete_blk(Array2D* block); int resize_blk(Array2D* block); int show_blk(Array2D* block, const char* msg); Array2D* load_file(const char* arquivo); O mínimo, mesmo: cria um bloco e retorna o endereço dele. apaga um bloco e retorna NULL aumenta o tamanho do bloco e retorna 0 se ok mostra o conteúdo de um bloco na tela e retorna 0 se ok load_file recebe o nome de um arquivo e carrega em um bloco, e retorna NULL se der erro ou o óbvio endereço do bloco criado. Claro que não vou tratar muitas condições de erro ou criar muitas operações aqui: trata-se apenas de um exemplo EXEMPLO: Usando isso com o arquivo "entrada.txt" Pokemon Megaman Megamente Kyrbi Kaku Eis como fica um programa que usa essas funções para carregar esse arquivo na memória e mostrar as linhas na tela. classifica em ordem alfabética e mostra de novo na tela apaga tudo #include "coisas.h" int main(int argc, char** argv) { char msg[80] = {0}; if (argc < 2) usage(); Array2D* test = load_file(argv[1]); if (test == NULL) return -1; sprintf( msg, "\n\n==> Carregando \"%s\" na memória", argv[1]); show_blk(test, msg); qsort(test->line, test->size, sizeof(void*), cmp_line); sprintf( msg, "\n\n==> \"%s\" depois do sort() na memória", argv[1]); show_blk(test, msg); test = delete_blk(test); return 0; }; Eis o que o programa mostra na tela Carregando "entrada.txt" na memória Criando bloco para 8 linhas, incremento = 16 linhas ==> Carregando "entrada.txt" na memória Bloco: 5 def 8 linhas. [Incremento = 16]: 1 Pokemon 2 Megaman 3 Megamente 4 Kyrbi 5 Kaku ==> "entrada.txt" depois do sort() na memória Bloco: 5 de 8 linhas. [Incremento = 16]: 1 Kaku 2 Kyrbi 3 Megaman 4 Megamente 5 Pokemon ***** Apagando bloco ***** Carregar o arquivo é essa operação: Array2D bloco = load_file("entrada.txt"); Nada mais. Entra o nome, se o arquivo existe sai o endereço do bloco. Eis um exemplo na tela do terminal para o programa chamado p... Forum > p Use: programa nome_do_arquivo Forum > cat entrada.txt Pokemon Megaman Megamente Kyrbi Kaku Forum > p entrada.txt Carregando "entrada.txt" na memória Criando bloco para 8 linhas, incremento = 16 linhas ==> Carregando "entrada.txt" na memória Bloco: 5 de 8 linhas. [Incremento = 16]: 1 Pokemon 2 Megaman 3 Megamente 4 Kyrbi 5 Kaku ==> "entrada.txt" depois do sort() na memória Bloco: 5 de 8 linhas. [Incremento = 16]: 1 Kaku 2 Kyrbi 3 Megaman 4 Megamente 5 Pokemon ***** Apagando bloco ***** Forum > Claro, em coisas.h tem as declarações #pragma once #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { size_t incr; // tamanho do incremento size_t limit; // tamanho disponivel para uso size_t size; // tamanho em uso agora char** line; // as linhas } Array2D; Array2D* create_blk(size_t size, size_t incremento); Array2D* delete_blk(Array2D* block); int resize_blk(Array2D* block); int show_blk(Array2D* block, const char* msg); Array2D* load_file(const char* arquivo); int cmp_line(const void*, const void*); void usage(); Claro que para usar qsort precisa de uma função de comparação e ela está aí. usage() é clássica em C e é mostrada se o cara esquece de dar o nome do arquivo na hora de rodar o programa. O código para as outras funções #include "coisas.h" int cmp_line(const void* one, const void* other) { return strcmp( *((const char**)one), *((const char**)other)); } Array2D* create_blk(size_t size, size_t increment) { Array2D* nb = (Array2D*)malloc(sizeof(Array2D)); if (nb == NULL) return NULL; char msg[80] = {0}; fprintf( stderr, "Criando bloco para %llu linhas, incremento = %llu " "linhas\n", size, increment); nb->incr = increment; nb->limit = size; nb->size = 0; nb->line = (char**)malloc(sizeof(char*) * size); return nb; } Array2D* delete_blk(Array2D* blk) { if (blk == NULL) return NULL; fprintf(stderr, "\n\n***** Apagando bloco *****\n\n"); for (size_t i = 0; i < blk->size; i += 1) free(blk->line[i]); // free lines free(blk->line); // free block free(blk); // free struct return NULL; } int resize_blk(Array2D* nb) { const size_t new_sz = nb->limit + nb->incr; char* new_block = realloc(nb->line, (new_sz * sizeof(char*))); if (new_block == NULL) { fprintf( stderr, "\tErro ao tentar aumentar bloco para %llu " "lines\n", new_sz); return -1; } nb->limit = new_sz; nb->line = (char**)new_block; return 0; } // resize_blk() int show_blk(Array2D* bl, const char* msg) { if (msg != NULL) printf("%s\n", msg); if (bl == NULL) { printf("show(): bloco não alocado\n"); return -1; } printf( " Bloco: %llu de %llu linhas. [Incremento = " "%llu]:\n", bl->size, bl->limit, bl->incr); for (size_t i = 0; i < bl->size; i += 1) printf("%4llu\t%s\n", 1 + i, bl->line[i]); return 0; } Array2D* load_file(const char* f_name) { // carrega o arquivo para dentro do Array_2D if (f_name == NULL) return NULL; fprintf( stderr, "Carregando \"%s\" na memória\n", f_name); FILE* F = fopen(f_name, "r"); if (F == NULL) return NULL; // arquivo aberto // cria o bloco: comeca com 8, incremento = 16 Array2D* nb = create_blk(8, 16); char line[250]; char* p = &line[0]; p = fgets(p, sizeof(line), F); while (p != NULL) { // ainda cabe? if (nb->size >= nb->limit) { resize_blk(nb); printf( "Bloco estendido para um total de %llu " "linhas\n", nb->limit); } // copia a linha // se a string termina em `\n` apaga size_t fim = strlen(p) - 1; if (p[fim] == '\n') p[fim] = 0; nb->line[nb->size] = (char*)malloc(1 + strlen(p)); strcpy(nb->line[nb->size], p); nb->size += 1; // le a proxima p = fgets(p, sizeof(line), F); }; // while() fclose(F); return nb; } void usage() { fprintf(stderr, "Use: programa nome_do_arquivo\n"); exit(EXIT_FAILURE); } É isso. Funciona para qualquer coisa. Eis um exemplo usando o próprio arquivo coisas.h ==> Carregando "coisas.h" na memória Bloco: 22 de 24 linhas. [Incremento = 16]: 1 #pragma once 2 #include <stdio.h> 3 #include <stdlib.h> 4 #include <string.h> 5 6 typedef struct 7 { 8 size_t incr; // tamanho do incremento 9 size_t limit; // tamanho disponivel para uso 10 size_t size; // tamanho em uso agora 11 char** line; // as linhas 12 13 } Array2D; 14 15 Array2D* create_blk(size_t size, size_t incremento); 16 Array2D* delete_blk(Array2D* block); 17 int resize_blk(Array2D* block); 18 int show_blk(Array2D* block, const char* msg); 19 20 Array2D* load_file(const char* arquivo); 21 int cmp_line(const void*, const void*); 22 void usage(); ==> "coisas.h" depois do sort() na memória Bloco: 22 de 24 linhas. [Incremento = 16]: 1 2 3 4 5 char** line; // as linhas 6 size_t incr; // tamanho do incremento 7 size_t limit; // tamanho disponivel para uso 8 size_t size; // tamanho em uso agora 9 #include <stdio.h> 10 #include <stdlib.h> 11 #include <string.h> 12 #pragma once 13 Array2D* create_blk(size_t size, size_t incremento); 14 Array2D* delete_blk(Array2D* block); 15 Array2D* load_file(const char* arquivo); 16 int cmp_line(const void*, const void*); 17 int resize_blk(Array2D* block); 18 int show_blk(Array2D* block, const char* msg); 19 typedef struct 20 void usage(); 21 { 22 } Array2D; ***** Apagando bloco ***** Forum > Sugiro testar em sua máquina e escrever de volta se não entender a ideia.

Não, não é assim. Você pode ter 8 maquinas virtuais em rede, todas hospedadas em uma máquina sem placa de rede. As placas de rede são tão virtuais quanto a máquina virtual. Em ambientes cloud vem até a necessidade de um switch virtual quando as VM que você usa são cooperativas. Não existe essa noção de wifi virtual. Todas as conexões da VM são virtuais. O que existe é em algum momento algo como um comando "attach" que liga a rede da VM com a rede do host, ou algum gateway. Uma ponte de rede (bridge) por exemplo pode ligar sua placa de rede virtual com sua placa de rede no host. Pode usar NAT também, ou um switch virtual. Não faz diferença se do lado do host a placa é wifi ou não. Se vai usar TCP/IP deve ter ethernet. Nada mais. wifi é ethernet. E half duplex. E cada conexão usa antenas dos dois lados. Se precisa ligar exclusivamente uma VM via wifi por alguma razão, uma possibilidade é fazer como te expliquei, usando um adapador USB. Claro que isso nada tem a ver com wifi porque pode fazer o mesmo com um adaptador USB para RJ45. Apenas vai trazer uma conexão USB física para controle exclusivo da VM. E daí usa os recursos que esse dispositivo te oferece. É como ligar uma placa de vídeo para uso exclusivo da VM (claro, desde que seu computador tenha mais de uma).

Entenda que o próprio shell foi escrito em C. Pode fazer qualquer coisa em C e muitas vezes usar um bat no Windows ou um script no Linux só vai atrasar as coisas. E mesmo assim há opções ais interessantes para transformar texto, como o clássico awk. Não entendi o que quer dizer. Onde não pode fazer comparações? O que quer automatizar que não pode fazer em C? O sistema foi escrito em C. O programa que eu te mostrei faz tudo o que precisa fazer. E até te mostrei como acessar as letras uma a uma em cada linha. ? Leu a parte em que falei sobre escrever uma série de printf de uma linha? Não deve escrever desse modo. E entenda que isso que escreveu é um loop: escreva como tal. Não há nada errado no que te mostrei. Mas seu programa tinha muitos problemas. Se resolveu algum devia ir postando as versões novas ou vai ser difícil te ajudar. Sobre uma pergunta que fiz: você tem um livro ou mais? Tem alguma referência de C? O que escreveu com relação a FILE e algumas conversões que usou não fazem sentido. Rodou o programa que te mostrei? Entendeu? Entendeu o que seria "escrever em torno dos dados, o que eu tentei mostrar nos 4 programas?

Resumindo: você não disse a velocidade de conexão que seu computador reporta para a conexão com a rede. Se está em algo como 187/163 como mostrou (não está claro que aqueles números se referam aseu computador) então a conexão está a 1000. Como eu disse, a conexão via cabo vai estar a 10, 100 ou 1000 mbps. E repetindo o que eu disse: deve testar a velocidade do micro na rede e não com esses medidores abstratos de conexão com a internet. E aí ver se seu computador está mesmo transmitindo e recebendo sem gargalos. Claro, desde que tenha um outro computador na mesma rede. E se ele estiver ok então seu problema não está aí. De todo modo, se não tiver mais nada usando a internet, daria pra esperar um pouco mais da conexão com a internet, algo perto de 300/350.

Sua placa de rede nada tem a ver com a velocidade contratada para acesso a internet. Ela provavelmente sequer está ligada na internet mas sim a uma das portas do modem, na tal LAN, a rede local. E lá é onde deve ver a velocidade da conexão, na LAN. Se usa Windows está na nas propriedades da placa de rede, e vai estar marcando 10, 100 ou 1000 para o seu caso. Se a placa é Fast Ethernet não vai nunca mostrar tráfego além disso. Pode esperar até uns 90 ou 95 mbps. Se a placa for gigabit não vai mostrar além de uns 900/950, e de novo nada tem a ver com a internet: deve testar transmitindo e recebendo algo dentro de sua rede local. Se desligar da internet sua placa de rede continua funcionando com a velocidade nominal dela. Cabo CAT 6 é um desperdício para essas velocidades. Precisaria disso para 10.000 mbps e mesmo assim até uns 10m provavelmente mesmo o cabo comum 5E funcionaria, a menos que esteja dentro de uma fábrica.

F7: bidimensional é a grafia correta, como em dimensão. Seu programa lê lexto e mostra texto, então mostre texto aqui e não essas imagens gigantes copiadas de sua tela. Ajude outros a ajudarem você: poste um mínimo arquivo de teste que mostra o que quer fazer, e um exemplo do seu problema acontencendo, em texto. Isso seria algo melhor que as duas telas gigantes: entrada.txt Pokemon Megaman Megamente Kyrbi Kaku Porque assim alguém pode copiar isso e colar em um arquivo e tentar reproduzir seu problema em minutos. E poste a saída do seu programa. Mas nem posso postar aqui a saída do programa que mostrou, porque ele sequer compila direito ainda. Sobre o programa: Quase todo o código está comentado. Qual o propósito? Esse comando, por exemplo: strncpy( &Text_Read[i][p], (char*)fgets( ((char*)getchar()), 1 * sizeof(char), ((FILE*)printf("%c", *(&One_Letra2)))), 1 * sizeof(char)); é algo que deve muito evitar, em especial se está começando a programar nessa linguagem. No caso de seu programa está errado mesmo, mas é algo que deve evitar mesmo que saiba o quie está fazendo. São muitas coisas que podem dar errado, isso se a ideia em si estiver certa. `fgets` pode dar errado. Não está sequer testando e já passa o valor como argumento para `strncpy`. Não é boa ideia. leia o manual: `printf` retorna um `int`. Qual seria o sentido de converter para `FILE~`, algo que nem é suposto para ser tratado pelo programador? o operador `sizeof` retorna 1 para `char`. Então tudo isso seria para de algum modo copiar uma letrinha e um `NULL`? pra que `strncpy`? Isso é algo que poderia ter comentado... Não seria melhor ver agora o tamanho da string e alocar do tamanho certo e copiar usando simplesmente strcpy? Está certo de entende o que é `FILE*`? Tem um livro? Mais sobre o código Seu programa tem muitos dos erros comuns que vemos aqui, e então vou copiar de uma lista que tenho e listar umas coisas que provavelmente deve evitar Não use acentos em nomes de variáveis ou comentários. Evite mesmo em strings a menos que o enunciado exija. Não vai aprender nada e só vai ter problemas. Mais ainda evite usar Unicode e coisas como emojis. Nada acrescenta ao código e não sair em muitas telas, ou vai sair outra coisa. E se imprimir o programa pode não sair nada ou algum lixo. Evite comentários como "main é a função principal" ou "declaração de variáveis" ou coisas óbvias desse tipo. Comente o porque está fazendo algo, escreva para você mesmo no futuro, tipo daqui a 2 dias quando pode não lembrar para que era aquele ponteiro, por exemplo. evite retornar void de funções: em geral é um desperdício. E muitas vezes um erro. Use argumentos nas funções, e retorne algo delas. É mais esperto e expressivo. Use alguma ordem em suas funções, como a ordem alfabética por exemplo. Vai gostar disso quando seu programa tiver 50 funções ao invés de umas poucas. Muitos IDE mostram uma lista das funções, em geral na ordem em que foram declaradas, de modo que você pode clicar no nome e o editor vai direto para o código, mas se estiverem em ordem é claro que você só ganha. Nunca use variáveis globais. Isso é um pesadelo e sempre vai cair na sua cabeça. Em geral é proibido em empresas e escolas. Não declare NADA que use memória fora de main(). Não declare mais que uma variável por linha. Não acrescenta nada e só dificulta a leitura. Inicialize todas as variáveis. Nunca leia valores do teclado para alimentar seu programa antes dele estar rodando. Só vai te atrasar e não acrescenta absolutamente nada. Use constantes, use funções que retornam a estrutura preenchida. Leia de arquivos: é trivial em C. Ao terminar os testes aí sim incorpore a leitura. Um programa interativo é chato para testar. Durante o desenvolvimento ninguém quer interagir com o programa. Nunca escreva um programa interativo, mesmo que seja o objetivo final. Alinhe seu código com algum critério. Evite longas linhas com mais de 60 colunas. Use nomes significativos para as variáveis e fuja de coisas como aux, aux1 e aux2. E não use nomes de variáveis enormes porque em uma expressão fica muito difícil de ler. não use fflush(): isso só está definido para fluxos de saída. Em alguns compiladores pode até funcionar, mas é um sinal de fez algo errado e não sabe como consumir os dados. não use setbuf a menos que saiba a razão de fazer isso. streams usam buffers porque é esperto e não o contrário. Não existe "lixo de teclado": necessidades como de flush() na entrada indicam apenas que não entendeu bem o que está lendo e o que é a entrada via teclado, free form: o usuário pode digitar qualquer coisa e é o seu programa que tem que se virar O teclado tem ao menos 105 teclas de liberdade e o usuário pode digitar qualquer coisa em qualquer ordem. evite ler do teclado a menos que seja o objetivo do problema. Ler de arquivos é muito mais simples, seguro e fácil de reproduzir. Não há razão para ficar parado em frente a tela minutos inventando nomes de campos e coisas assim: o efeito é que vai acabar não testando direito porque é difícil controlar e repetir testes. Não misture entrada de dados ou formatação com a apresentação dos dados ou a lógica do programa, Isso é um desastre para manutenção e desenvolvimento. Um printf() de 6 linhas é **muito**, mas muito melhor que 6 printf() de 1 linha. E se só vai mostrar o texto puts() é ainda melhor e dezenas de vezes mais rápido que uma série de printf(). Escreva seu programa em torno dos dados. O que quer criar é o que todo programa `C` recebe: uma lista de strings. Esse é o protótipo normal de `main`: int main( int argc, char** argv); E são os argumentos que seu programa --- e todo programa `C` recebe: uma lista de strings com o que o usuário digitou na linha de comando. O primeiro argumento é sempre o nome do programa. Isso deveria ser ensinado no PRIMEIRO programa do aluno, aquele tal `Hello World`. Mas não sou eu quem ensina ou decide isso Os dados: o que o programa recebe? O que o programa cria? O programa recebe o nome de um arquivo e cria uma lista de strings. Igualzinho ao que o sistema faz para todo programa `C`, como eu disse. Então faça igual, já que dá certo para todo programa vai dar certo para o seu: char nome_arquivo[250]; const char[] arquivo_padrao = "entrada.txt"; typedef struct { unsigned n_linhas; // quantas linhas no arquivo? char** L; // o vetor de linhas } Array; Já seria um bom começo: tem onde ler o nome do arquivo. tem um nome padrão para o caso do cara não digitar nada. E assim para testar não tem que ficar digitando nomes de arquivo duzentas vezes. E pode ter arquivos de teste já separados. na saída vai ter o tal `Array` onde diz que o texto carregado tem n_linhas e as linhas vão estar todas arrumamindas no vetor L. Parece simples assim. E #include <stdio.h> typedef struct { size_t N; // quantas linhas no arquivo? char** L; // o vetor de linhas } Array; int main(int argc, char** argv) { char nome_arquivo[250]; const char arquivo_padrao[] = "entrada.txt"; return 0; } já compila e roda. Claro, só para apoio moral porque não faz nada. São mesmo duas dimensões. De todo modo entenda que C sequer tem arrays multidimensionais, como FORTRAN. Só existe array. Mas tem array de array, array de array de array e assim por diante... Então se declarar o simples char** Linha; e gravar seu arquivo lá, vai ter a linha 0 em Linha[0], a linha 3 em Linha[3] e tal. Linha[0] é o que? char*, assim foi declarado. Então Linha é char** *Linha é char*, Linha[0] é char* **Linha é uma letrinha, char, assim foi declarado. assim sendo, Linha[12][0] é a primeira letra da linha 13 a ultima letra da terceira linha seria o que? Seguindo com o exemplo que mostrei: #include <stdio.h> #include <stdlib.h> typedef struct { size_t N; // quantas linhas no arquivo? char** L; // o vetor de linhas } Array; int main(int argc, char** argv) { char nome_arquivo[250]; const char arquivo_padrao[] = "entrada.txt"; char* uma = "uma linha"; char* outra = "outra linha"; Array exemplo = {.L = NULL, .N = 0}; printf("exemplo tem %llu linhas\n", exemplo.N); exemplo.L = (char**)malloc(2 * sizeof(char*)); exemplo.L[1] = uma; exemplo.L[0] = outra; exemplo.N = 2; printf("exemplo tem %llu linhas\n", exemplo.N); return 0; } Isso mostra exemplo tem 0 linhas exemplo tem 2 linhas Mas é claro que vai querer mostrar o que tem dentro do vetor, as linhas, então uma função assim int ch_mostra(Array*,const char*); // mostra as linhas na tela Seria a popular "mão na roda" e ainda aceita um título pra você não ter que ficar colocando os ultra chatos printf aqui e ali... Seria difícil escrever? int ch_mostra(Array* arr,const char* msg) { if (arr == NULL) return - 1; // sem linhas if (msg != NULL) printf("%s", msg); printf(" Vetor tem %llu linhas\n", arr->N); for (size_t i = 0; i < arr->N; i += 1) printf("#%llu\t\"%s\"\n", i, arr->L[i]); printf("\n******\n\n"); return 0; } 10 linhas está ok. E mudando o programa aí de cima #include <stdio.h> #include <stdlib.h> typedef struct { size_t N; // quantas linhas no arquivo? char** L; // o vetor de linhas } Array; int ch_mostra(Array*,const char*); // mostra as linhas na tela int main(int argc, char** argv) { char nome_arquivo[250]; const char arquivo_padrao[] = "entrada.txt"; char* uma = "uma linha"; char* outra = "outra linha"; Array exemplo = {.L = NULL, .N = 0}; ch_mostra(&exemplo, "[array vazio]\n\n"); exemplo.L = (char**)malloc(2 * sizeof(char*)); exemplo.L[1] = uma; exemplo.L[0] = outra; exemplo.N = 2; ch_mostra(&exemplo, "[array deve ter duas linhas]\n\n"); return 0; } int ch_mostra(Array* arr,const char* msg) { if (arr == NULL) return - 1; // sem linhas if (msg != NULL) printf("%s", msg); printf(" Vetor tem %llu linhas\n", arr->N); for (size_t i = 0; i < arr->N; i += 1) printf("#%llu\t\"%s\"\n", i, arr->L[i]); printf("\n******\n\n"); return 0; } E na tela mostra [array vazio] Vetor tem 0 linhas ****** [array deve ter duas linhas] Vetor tem 2 linhas #0 "outra linha" #1 "uma linha" ****** É melhor escrever em torno dos dados e começar assim. E sobre a última letra da última linha? // 'len' = tamanho da ultima linha size_t len = strlen(exemplo.L[exemplo.N - 1]); char ultima = exemplo.L[exemplo.N - 1][len - 1]; printf( "\n\n\tUltima letra da ultima linha: '%c'\n", ultima); E colocando isso no programa #include <stdio.h> #include <stdlib.h> typedef struct { size_t N; // quantas linhas no arquivo? char** L; // o vetor de linhas } Array; int ch_mostra( Array*, const char*); // mostra as linhas na tela int main(int argc, char** argv) { char nome_arquivo[250]; const char arquivo_padrao[] = "entrada.txt"; char* uma = "uma linha"; char* outra = "outra linha"; Array exemplo = {.L = NULL, .N = 0}; ch_mostra(&exemplo, "[array vazio]\n\n"); exemplo.L = (char**)malloc(2 * sizeof(char*)); exemplo.L[1] = uma; exemplo.L[0] = outra; exemplo.N = 2; ch_mostra(&exemplo, "[array deve ter duas linhas]\n\n"); // 'len' = tamanho da ultima linha size_t len = strlen(exemplo.L[exemplo.N - 1]); char ultima = exemplo.L[exemplo.N - 1][len - 1]; printf( "\n\n\tUltima letra da ultima linha: '%c'\n", ultima); free(exemplo.L); return 0; } int ch_mostra(Array* arr, const char* msg) { if (arr == NULL) return -1; // sem linhas if (msg != NULL) printf("%s", msg); printf(" Vetor tem %llu linhas\n", arr->N); for (size_t i = 0; i < arr->N; i += 1) printf("#%llu\t\"%s\"\n", i, arr->L[i]); printf("\n******\n\n"); return 0; } Que mostra [array vazio] Vetor tem 0 linhas ****** [array deve ter duas linhas] Vetor tem 2 linhas #0 "outra linha" #1 "uma linha" ****** Ultima letra da ultima linha: 'a' Para que isso? Só para mostrar como acessar as letras dentro da estrutura.

@Fernando Cardoso de Melo Você pode virtualizar o protocolo, mas o rádio não... Nem as antenas da placa. Se a própria máquina é virtual e as redes são virtuais e placas, onde entra um rede wifi diferente? As conexões de rede da máquina virtual são, claro, virtuais, e pode criar várias. Se por alguma razão precisa de outras rede wifi em cada VM use por exemplo adaptadores USB para cada VM que precisa disso. No host use o comando apropriado para anexar o dispositivo USB físico à máquina virual apropriada e instale o sw como outro qualquer.

@xlemes Esse modelo é um dos que te citei. É como o AX50 e o EX510. Existem sutis diferenças entre esses 3 mas não vão afetar o seu uso e o de quase nenhum usuário domésico. Tenho 3 desses mas nunca usei nem recomendei esse recurso. Acho que em casas é um tiro no pé e em uso profissional tem outras ferramentas, algumas das quais eu até listei. Mas fique atento: quando chegaram esses aparelhos no BR o controle de banda estavam para ser incluídos numa atualzação de um tal pacote de segurança HomeCare. Nunca vi rodando. Nunca vi esse pacote e não sei se foi disponibilizado de fato. Confirme se isso foi de fato lançado. Nos modelos anteriores tinha isso de uma certa maneira. No AX73 está implementado do jeito novo. Esse artigo explica um pouco disso. E esse outro fala do modo novo, com a nova interface. Confirme se esses modelos intermediarios tiveram isso de verdade implementado. No Archer C7 tinha:

@xlemes Eu não compraria sem WIFI6 de jeito nenhum. Mas por mais de mil reais um aparelho da classe de 3000 mbps não compraria também. Como precisa desse particular recurso e sabe que tem nesses ASUS acho que a escolha é simples. Compre o AC de menos de 400. E quando precisar de mais tráfego no wifi compre algo de outra marca. Os EX510 ou AX53 da TP-Link por exemplo são muito efetivos e gerenciáveis e custam menos de 500. Vendo rapidamente em uma lista de preços: Um ASUS ROG AX3000 custa perto de 2600 reais. Certo que ROG é meio grife, mas ainda assim são 3000 mbps. Por outro lado um GX90 da marca TP-Link custa 2200 e é AX, só que para 6600 mbps, Tri-band com processador quad-core e oito antenas. E a porta WAN de 2.5G, que não vai estar no limite de 1g como praticamente todos os outros. Um Xiami AX5400 tem porta WAN 2.5 também e custa uns 900 reais. Parece muito caro ASUS. E tem um AX73 tp-link e vi agora que tem controle de banda separado para entrada e saida por porta. É AX para 5400 mbps, um bom número. Custa perto de 700 reais, mas são 5.4gbps em wifi6 ao invés de 1,9 em wifi5. Pode ser uma opção.

Eu acho que sim. Mas é wifi 5. É muito antigo pra ser comprado novo e não devia custar quase o preço dos novos, que são muito melhores. Não tem nenhum ASUS wifi6 nessa faixa de preço? Estranho.

@xlemes os da ASUS que eu disse tem esse trem. Os Tp-link eu acho que não, ao menos não me lembro. Só que esses a ASUS são AC e são assim caros eu acho. Procure pelos ASUS sucessores dos a, os AX 1900 ou 3000 são faixas de velocidade e todas marcas tem modelos assim Então procure um desses, ASUS padrão AX entre 2 e 3000 Mbps por menos de 500 reais O que seria bem razoável

Já comprei vários desses. Os últimos foram ex510 que dão similares. São bem efetivos, mas não acho que tenham esse recurso que quer...

@xlemes são comuns, mas não compraria hoje nenhum que não fosse compatível com WIFI6 ou 6E, esses AX. A diferença de uso é grande e a de preço quase sumiu. Procure algum AX1900 ou AX3000 dessa marca (meu palpite gratis)

Tudo que tem a ver com a placa de rede. Mas mesmo no caso da memória, entenda que parte do POST, aquilo que roda quando liga a maquina, identifica e sincroniza tudo da melhor maneira que a eletronica na placa acha possível a cada boot. Isso inclui CAS, latências e temporizações de memória. Mudar isso fora do automático em geral afeta a estabilidade ou mesmo inviabiliza o boot. Mas uma prática comum de overclocking é com a RAM. E achar um valor mais alto e que funcione ok é algo sim para salvar. E é algo muito individual. Pode ser que funcione com 2 ou 4 pentes de uma certa memória mas mesmo que troque um só deles pode mudar algo. perfis XMP são exatamente para isso então é até estranho não ser o padrão para sua placa. Mas isso não deve interferir com o uso da placa de rede, que é seu problema agora

Essa é uma distinção importante. A primeira. Se o problema de agora é o mesmo de antes então ela não sumiu do gerenciador. Se sumir aquele ícone não aparece. Se o ícone aparece ela está presente. Apenas não tem conexão. Pode ser físico ou poderia estar configurada errada, mas está lá. não tem a ver com a tal bateria. Ela apenas salva a configuração. O máximo que pode mudar lá na configuração do tal BIOS --- sim, BIOS é masculino --- para não conectar é desabilitar a placa e já sabemos que não fez isso. No sistema pode fazer muitas coisas. No geral não há o que configurar no sistema. Tudo deve ficar no automático. Tudo.

@rhwinckler por certo não é a bateria. Precisa identificar algo mais objetivo sobre o que é "cair". A placa desaparece do gerenciador de dispositivos ou a conexão desaparece no sistema? Comece por aí.

O marketing sempre cria novos conceitos... Mas ao menos esse --- ASUS --- teve o cuidado de não escrever QoS na opção. QoS não tem a ver com limite de tráfego e sim com priorizaçao de pacotes por protocolo. Foi criado para VOIP (telefonia) e streaming. De todo modo entenda que não está claro que isso tenha a ver só com a internet, como já expliquei. E que deve usar números constantes e não porcentagem, pela simples razão de que o tráfego é variável. Contratar por exemplo 100 mbps é contratar um limite. Pode variar muito. Em geral muito para menos e um pouco para mais em certos horários. E o limitador como já disse vai atuar todo o tempo, mesmo que não tenha ninguém usando o resto da banda. Pode ser um "tiro no pé". RT-AC66, RT-AC68 e outros da mesma geração dessa marca tem esse recurso exatamente? Mas já disse um certo numero de vezes que quer controlar por porcentagem

@rhwinckler remontar maquina, instalar o sistema de novo ou mesmo instalar outro sistema pode ser exagerado para resolver um problema de conexão. Deve antes gastar seu tempo identificando o problema. Esses protocolos e velocidades de conexão são de vinte anos atrás e já deu tempo para os desenvolvedores e fabricantes se acostumarem com eles. Seu computador não está nunca conectado a internet. Apenas com a rede local. E você até sabe disso porque ligou com outros computadores. Desconfie do cabo e do soquete em sua placa. Use outras portas do roteador, troque os terminais. Verifique os terminais no soquete de sua placa, essas coisas. BIOS e drivers também não acrescentam muito: tudo isso é antigo e essa placa usa chipset dos mais comuns do planeta: Realtek 8111

Se sua pesquisa identificou que o cabo utilizado suporta apenas 1% da banda que o provedor que usa o cabo vende... Desconfie de seus resultados. Coaxial vai muito além de 1gps. Talvez os "resultados" que encontrou estejam em gigaBYTES por segundo...

@BorgesBFC Seu problema não está com a versão de Windows ou com drivers. Essa coisas são muito antigas, como te disse. Sua placa é comum, gigabit é de 1999. Há poucos fornecedores de drivers e chips de rede. Sua placa usa Realtek, talvez o mais comum do planeta, embora a versão 8118 seja bem recente. E seu problema nem está com BIOS. É um pouco ingênuo imaginar que um fornecedor em escala mundial --- Gigabyte nesse caso --- tenha que gerar novas versões de BIOS para conexão gigabit do século passado. E usando um chipset Realtek. Você pode ter um conector físico na placa mais sensível que os outros que usou. Entenda que se conecta a 100 e não a 1000 tem defeito intermitente em um dos pinos 4 5 7 ou 8. Se fosse nos pinos 1 2 3 e 6 não teria conexão alguma porque FE usa 4 pinos e Gigabit usa os 8. E se o pino de fora de sua placa, o ultimo, 8, estiver meio torto e mais distante do conector quando encaixa? O 1 está ok ou a conexão seria intermitente em termos de suceso/ fracasso. Não há conexão se o pino 1 não tiver sinal, como expliquei. Inverta as pontas do cabo de rede. Troque os conectores. Verifique com cuidado os conectores na placa. Entenda que os pinos 4 e 5 ficam bem no meio do soquete. Um alicate ruim, desbalanceado, pode gerar problemas exatamente na parte central e os conectores sua placa podem estar por azar um pouco mais afastados aí. Assim, quando junta o cabo e a placa pode acabar com conexão intermitente...

@Veronica Sales Sim, podem ser apenas um dos conectores. Troque os dois. Troque antes a porta no switch onde está conectado. O que eu disse sobre um cabo curto e testar na mesa é em resumo colocar o aparelho ligado em uma mesa onde tenha um computador com a pagina de configuração dele aberta, e onde ele possa atrair alguns clientes e ver o que acontece. E consultar os logs. Para tentar interceptar uma falha em tempo real. Pode usar um script de monitoramento também, que alerte quando ele se desconecta. E pode ver se não coincide por exemplo com o fim do lease do DHCP se usa isso para ele