Ansi C

@Victor Vilardo Uma pergunta, é atividade escolar?

Boa tarde, É tão fácil perder uma parte do trabalho quando toda programação é "depositadas" em um só lugar, por exemplo, na função main. Há rotinas sequencias que foram organizadas dentro dela, ainda assim, a sugestão é organiza tudo a sub-rotinas. Esse não é de todo o caso, mas observe que uma correção fez perder outra tarefa que em uma função (isolada) só com seu trabalho, suas tarefas e, principalmente, livre da correção de outras... seria menos um problema. " Parece crueldade está recomendo reiniciar o exercício, tudo de novo, mais dessa vez organizando em sub-rotinas (função), mas, é uma sugestão. "

Boa Tarde, "De acordo com meus conhecimentos..." (Fifi de Assis) O exercício pede justificativa com narração do problema, causa e solução, mas que VOCÊ espertamente repassou para fórum. " A referência\citação da matriz (seu nome) é um sinal alegórico (simbólico) para o endereço na memória do primeiro elemento, por essa razão o índice 0, que é neutro da adição, representa o primeiro de todos os elementos da matriz. Cada elemento é uma variável, cada índice incrementa e gera o próximo endereço a partir da citação. Essa é uma discussão antiguada (chata). "

Bom Dia, A programação faz alteração na variável de nome num enquanto determina a codificação de binários e com o termino (das ações) o valor na variável é 0. Entenda, isso significa que precisa persistir o valor originado na entrada antes de ir para próxima conversão, ou se ainda não entendeu, precisa de uma variável de ‘backup’ ou auxiliar para recuperar o valor na variável de nome num. "

A que pena, bastava simular (brincando) com carrinho imaginário (ou real) seguindo as regras. Com tempo notaria que seu carrinho é uma abstração que podemos relacionar, por exemplo, ao ponteiro de um relógio de ponteiros (rel. analógico) ou da bússola do GPS (Girando Para Sempre). 0 +-------------+ | | D > Direção Horária (incremento) | * --> | 90 E < Direção Anti-horaria (decremento) | | +-------------+ "

Boa Noite, Essas estruturas primitivas não permitem desligar e ligar células de memória em qualquer ponto, isso é perturbador quando precisas inserir um novo dado, e não é no fim delas. Uma alternativa é copiar tudo uma posição a esquerda a partir do seu último elemento (tail) até a posição desejada inclusive ela, livrando-a para o novo dado. " Basicamente, programe um 'loop' que percorre o vetor de trás para frente (do último elemento até aquela na posição desejada) enquanto copia no próprio array seus dados, para isso faça o índice a direta (do sinal de atribuição''='') 1+ que o da esquerda. array [index + 1]= array [index] Antes de tudo é preciso determinar se o novo dado é uma duplicata, logo essa parte das ações de inserir é necessário aqui também. Depois fazer de inserir (que insere na última posição) um método derivado de inserePosicao é fácil só para reutilizar o código, porém não é necessário. "

Boa Tarde, Se gavou em ‘string’, já estão separados na memória e possíveis de acessar, individualmente, pelo ponteiro. Mostra como tu fizeste! "

Como fica isso em palavras, nessa altura @Midori tornou trivial, ainda sim, estou com vtd de falar. Seria algo como: A partir {da Base 2 (de 0 até 10) até a Base 10}. Um ‘loop’ chamado Base (2 até 10) Um ‘loop’ chamado Expoente (0 até 10) Interessante é VOCÊ implementar o código com FOR, para vermos como faz. "

Boa Tarde seu moço, Por que é mais satisfatório para ti que outro resolva, meu organismo, por exemplo, tem aversão aqueles que resolvem meus assuntos. Resolução segundo os dicionários é a maneira para chegar a solução de uma questão. Eu penso que era Euclides que apresentava os elementos e cobrava de seus discípulos uma aplicação, na prática. Imagino que até hoje tem discípulo no tumulo se revirando para estabelecer as práticas para o seu mestre. Ainda hoje é assim, o professor apesenta os fundamentos e espera que o aluno (por vezes sozinho) estabeleça uso prático mediante exercício com situações problema. Geralmente, antes de tudo exemplificamos depois pedimos um exercício quase igual (semelhante). Não é uma lição de moral, é só um comentário, inocente: superação e mais divertido, importante não é a resolução e sim o EU que alcança, sem dividir mérito com outros porque tenho o entendimento; coisas chatinhas desse tipo. " Seria antiética, de minha parte, apresentar uma resolução para ti, mas o colega de código acima se prontificou a somente ajudar, o que é bem legal. Aproveita a oportunidade para aprender com ele que é mais experiente. Decerto, eu posso ajudar um pouco. "

Boa Tarde, Manipulação de ‘string’ implica conhecer os ponteiros porque as funções da biblioteca que lida com essa estrutura ("string") usam essas variáveis (ponteiros) para aloca\cópia (os antigos dizem: passagem) de endereço. " A biblioteca string.h é um arquivo de cabeçalho padrão responsável por manter os protótipos de funções de manipulação de strings em C, consulte a documentação antes de usar uma função dessa, a maioria esquece e perde a oportunidade de descobrir algo novo, e sozinho. Veremos se algum corajoso escreve o seu resumo ou aula sobre esse assunto, já eu nunca "assuntei" muito “strings” porque no meu ramo é chato (para todos). "

Boa Tarde Jovem, Esse é um assunto muito interessante, mais sem prática esqueci, ainda recordo que o conceito de um vetor (tabela) de ponteiros para listas organizadas segundo uma função (função de espalhamento) que com as chaves se gera um código (índices a tabela). " Um assunto até "assuntado" nos históricos do fórum: https://www.clubedohardware.com.br/search/?q=hash&quick=1&type=forums_topic&nodes=177 Uma importunidade de revisão, inclusive para "esta persona con la que hablas" "

Bom Dia, Eita! Pode parecer obvio para quem programa em C++, não é meu caso, só diga mesmo assim o queria fazer na linha 24? return p1.GetX() const { m_p1; }; Já fica a deixa para quem entende dessa *****. "

Oxi !!! Pare por favor. https://onlinegdb.com/rJVbWiSvw

Estranho mesmo a sua pouca capacidade de interpretar, mas não é surpresa nenhuma, haja vista que se um desenho não é o bastante então não posso ajudar. Pior, Continuo as voltas nesse postagem exatamente só por causa desse detalhe que é totalmente pessoal. Mas vamos lá, como disse essa é a sintaxe e a nomenclatura corretamente adequada correspondente a fala: ponteiro para vetor de Int. Diferente do que apresentou como certo. Agora quem está se defendendo sou eu, mas nem precisaria fazer disso, se não gostou do meu exemplo o problema é seu, "vida que segue" e não pense que está me ajudando porque não está: pois, uma situação comum tão simples assim tem um exemplo igualmente simples no ponto que explora tão-somente os algoritmos de correções e alerta do compilador. Mas a culpa é exclusivamente tua porque só descobre que tem algo a dizer depois que lê uma postagem e faz comentário, sem nexos, ignorando os fatos. Não acontecer nada significa que os comandos estão certos, o objetivo foi esse mesmo. E discordo que não existe relação com tópico, mais uma vez a interpretação. A pastagem, no momento que trata de vetores considera, mesmo que implicitamente os ponteiros de todos os tipos, ainda assim, não há necessidade de dimensões ou nomenclatura para além de um ponteiro de int. Devidamente esquematizado explorando os fatos. int y[] = {0, 2, 3, 4}; test(int testt[]) --> int testt [] ^--------> é só outro nome para int *testt | +--------> test(y): test (int *tesst= y) ^-------------------= &(y[0]) +-------+-------+-------+-------+ y | 0 | 2 | 3 | 4 | ^ +-------+-------+-------+-------+ | ^ | | +-----+---> 0x100407000 | +------> &(y[0])= 0x100407000 | +------> &(y[1])= 0x100407004 | +------> &(y[2])= 0x100407008 | +------> &(y[3])= 0x10040700c Descobri há muito, essa é uma discussão com mais de 10 anos na falta de um termo mais adequado: uma besteira de tão fácil, algo relativamente simples e coerente que segue a semática geral: "desalocação" de um ponteiro de vetor é um tipo vetor, de um ponteiro de int um int. ><

Eu pensei que um desenho seria mais acessível, me enganei, pelo visto é necessário mais que isso. Como assim não pode! Isso difere de não deve, pois, pode e não será notificado a depender do nível do alerta, isso porque ao contrário de sua opinião testt uma variável do tipo ponteiro para int, apesar de sua experiência demostra não entender corretamente que um PONTEIRO PARA VETOR DE INT tem esta nomenclatura int (*) []. Só um exemplo correto e adequado para ilustrar os fatos da linguagem C de programação, main (void) { int vetor [10]; // Vetor do tipo int [10] int (*pvetor) []; // Um ponteiro para um vetor de int int *p; // ponteiro pvetor= &vetor; // endereço de vetor ->> ponteiro de vetor p= vetor; // endereço do primeiro elemento de vetor ->> ponteiro } Qualquer compilador com atualização em 2010 compila sem problema porque não há erros. PS.: Estou caçando principalmente porque fico rodando enquanto leio "defezinhas"

Mas diferente do que a maioria tende a difundir, a cópia e do valor no ponteiro (ou referência), porém não o ponteiro. Caso contrário em que a cópia fosse do ponteiro teríamos um alias (outro nome) para o endereço,ou para um ponteiro. No caso, ao comandar: testt= 0x0, trocaríamos o endereço do primeiro elemento de array também para 0, porque nessa hipótese, que nada tem a ver com os fatos em C, testt é outro nome para array dentro da função .

Dessa vez é um erro de interpretação, mas é que não há como erra na interpretação porque fui suficientemente claro, ainda assim, surge um ou outro qualquer que não vai conseguir, ou fingir não entender. Quando declaramos o vetor int array []= {1,2,3,4}; // array é tipo int [] No (situação) argumento da função é um endereço para o primeiro elemento, assim já citado int y[] = {0, 2, 3, 4}; test(int testt[]) --> int testt [] ^--------> é só outro nome para int *testt | +--------> test(y): test (int *tesst= endereco do primeiro elemento) ^------------------= &(y[0]) OU y Não o array, mas sim o ENDEREÇO do primeiro elemento do array que são duas coisas. Por exemplo, o operador sizeof não operaria o array, dentro da função, porém sim o ponteiro que é o parâmetro da função com cópia do endereço do primeiro elemento do array (porém não o array). Até os mais experientes tem dificuldade para aceitar esse fato. Em C as passagens são de valor, às vezes, ponteiros são chamados de referências esse é o motivo da confusão que alguns fazem, mas é tudo uma ilusão. A passagem (cópia de argumentos) em C são de valores e um ponteiro é uma variável (especial) que carrega o endereço, que por vezes são chamadas de referências. Entendo que cometeu um erro de interpretação, observe mais atentamente o esquema que está tudo suficientemente claro;

Eu meio que conduzi esse entendimento, porém o esquema mostra que 'vira' o argumento (valor) para um variável do tipo ponteiro que é um parâmetro da função. Está esquematizado que 'y' é só um nome para um endereço, diferente de variável ponteiro. Ponteiro é uma variável (não primitiva) que recebe valores, logo a passagem por referência é uma ilusão, somente há passagem por valor. No caso especial dos ponteiros o valor é um endereço. *Variáveis tem nome, tipo, valor e endereço.

Pensei outra forma nada genial, mas suponha que já tem uma função que copia n caracteres. char * cstring_copie_n (char destino [], char const origem, int unsigned n); Para implementar a do exercício, basicamente, chamaria a que copia (reutilizando código) 2x. char * cstring__concatene (char const string1 [], char const string2 [], n) { /*... pega os tamanhos */ size_t string1_tamanho= cstring__comprimento (string1); size_t string2_tamanho= cstring__comprimento (string2); /*... Aloca memoria [static, heap] para variavel string_r */ char *string_r= /* MEMORIA ALLOC: string1_tamanho + n + 1 */; /*... Lembre-se unsigned (-1) é o máx uint. */ (void) cstring__copie_n (string_r , string1, -1); (void) cstring__copie_n (string_r + string1_tamanho, string2, n); return string_r }

São nomes diferentes para um argumento. O argumento nesse exemplo é o endereço, na memória, do primeiro elementos da variável indexável (vetor) 'y'. int y[] = {0, 2, 3, 4}; test(int testt[]) --> int testt [] ^--------> é só outro nome para int *testt | +--------> test(y): test (int *tesst= y) ^-------------------= &(y[0]) +-------+-------+-------+-------+ y | 0 | 2 | 3 | 4 | ^ +-------+-------+-------+-------+ | ^ | | +-----+---> 0x100407000 | +------> &(y[0])= 0x100407000 | +------> &(y[1])= 0x100407004 | +------> &(y[2])= 0x100407008 | +------> &(y[3])= 0x10040700c

Para não erra na função do enunciado use somente a linguagem (vetores; ‘loops’ e estruturas de decisão), ou seja, na composição dessa função não se chama funções da biblioteca padrão e de nenhuma outra. RETORNA uma nova “string”, compreende-se que as ‘strings’ dos parâmetros são parcelas e não podem ser alteradas. char * string_concat (const char string1[], const char string2[], unsigned n); Dos comandos necessários me pareceu conhecer todos, exceto IF-ELSE

"Imprima o array com k elementos por linha" significa que a cada K elemento(s) impresso(s) imprima nova linha ('\n') em seguida. Se K= 7 a cada múltiplo de K (mK % K = 0) imprimisse uma nova linha até 31, tem-se 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 O fragmento de código abaixo é uma codificação da decisão para K= x if ((mK % K) == 0) printf ("%d\n", mK); else printf ("%d ", mK);

Talvez realloc ainda não seja a função certa, o mais correto segundo esse texto é: malloc ou calloc combinada com loop para copiar e free.

Exemplos de listas existem aos montes. Ainda que tenha membros que a cada postagem desse tipo acredita escrevê uma versão melhorada, superior e personalizada que atende as necessidades de todos, as dúvidas com relação às listas são sempre as mesmas; é pura ilusão então escrever mais uma (exemplo). Faz sentido sim busca exemplos que já existem de lista com vetores dinâmico e estático para depois tratar só as dúvidas. Para esse caso use realloc, antes de inserir um elemento na lista verifique se é o último. Como sua lista tem metadados dois deles será: Capacidade / Tamanho Físico Tamanho / Tamanho Lógico Se a capacidade e o tamanho estão iguais então é preciso expandir a capacidade e copiar os dados +--------++--------+ +--------++--------+ LISTA | 0 || | LISTA | 0 || 0 | | +--------++--------+ | +--------++--------+ | | +---> Capacidade: 2 +---> Capacidade: 2 | | +---> Tamanho: 1 +---> Tamanho: 2 REALLOC * 2 +--------++--------++--------++--------+ LISTA | 0 || 0 || || | | +--------++--------++--------++--------+ | +---> Capacidade: 4 | +---> Tamanho: 2 O fragmento de código abaixo realoca a memória para o dobro da capacidade e copia os dados para novo local por meio da função realloc depois retorna 1. size_t nova_capacidade= lista->capacidade * 2; int *elementos= realloc (lista->elementos, sizeof (*elementos) * nova_capacidade); if (elementos == NULL) return 0; lista->capacidade= nova_capacidade, lista->elementos= elementos; return 1;

O enunciado está perfeitamente elaborado para não deixar interpretação, só há compreensão clara de 3 sub-rotinas com tarefas bem definidas. Resolvi e agora qual é sua dúvida inicialmente? Acredito que alocar não é.