Jump to content
Fórum Script Brasil
  • 0

For para gerar nomes de ponteiros


Question

Olá pessoal,

Sou completamente inexperiente em programação e especialmente em C e C++, e estou tentando fazer um for que gere nomes de ponteiros sequenciais (estes ponteiros já são vetores), mas está retornando erro ao compilar (error: lvalue required as left operand of assignment pp->others.index + q= (int *) malloc(mmc * sizeof(int)); com uma seta para o sinal de =)
.

Estou fazendo:

for (int q = 0; q < mmc; q++){	//valor resultante do mmc de 7 e 9
		pp->others.index + q = (int *) malloc(mmc * sizeof(int));
		}

a intenção seria que eu tivesse others.index0, others.index1, ..., others.index62.

Não consegui achar meu erro. Podem me ajudar?

 

Link to post
Share on other sites

12 answers to this question

Recommended Posts

  • 0

sobre o uso da setinha

//quando o novo tipo de alguma estrutura for um ponteiro poderá usar setinha ->
//resumindo o que permite usar -> é possuir um asteristico(*)
//ex 1:
struct estrutura5{
 int membro;
};
// Acessando através de uma variavel não-ponteiro: e
estrutura5 e;
e.membro = 0;
// Acessando através de uma variavel ponteiro: e2
estrutura5* e2;
e2->membro = 0; // ou 
(*e2).membro = 0;


//ex2:
struct no{		
  int dado;
  struct no *prox;
};
struct no *ptr = (struct no*) malloc(sizeof(struct no));
ptr->dado // ou
(*ptr).dado
ptr->prox// ou
(*ptr).prox

ponteiro-> é um jeito mais curto de escrever de (*ponteiro). , é uma abreviação mais legível.
Esses operadores  -> e . são similares. Apenas você usa -> quando o que está à esquerda é um endereço e usa "."
O operador "." (ponto) é utilizado para acessar membros em estruturas cuja variável não seja um ponteiro.
O operador "->" (seta) é utilizado para acessar membros em entruturas cuja variável seja um ponteiro. É uma abreviação para "(*variavel)." .

voce postou um pedaço de algoritmo e ninguém vai adivinhar o que mais que voce escreveu muito menos a intenção que teve quando tentou escrever essas coisas e alocar a memoria dinamicamente

 

Link to post
Share on other sites
  • 0


Obrigado Herbert, pela maravilhosa explicação. Me ajudou a entender um pouco mais de C++ (já que eu entendo quase nada). Este código foi me passado por um professor e pediu para alterar de forma a fazer a alocação dinâmica do vetor others.coicidentes de forma que ele tenha de 0 até mmc. Vou postar toda a função:

t_pp_bd * genPP(t_bd * pattern, t_bd * pattern2, int mmc) { //pattern tem os valores de k e v, onde v é o tamanho total do pattern e k as posições válidas, por exemplo: pattern 7,3 diz que são 7 posições sendo 3 com valor 1 (ou true).

    t_pp_bd * pp;
    int i, j, z, w, a, b, c, d, e, f, h, k, t, index, offset;

    /*
     * Allocate structures.
     */

    pp = (t_pp_bd *) malloc(sizeof(t_pp_bd));
    pp->offsetZero.coincidences = (int *) malloc(pattern->k * pattern2->k * sizeof(int));  //coincidentes verifica se o a posição k válida do pattern casa com a posição k válida do pattern2
    pp->offsetZero.index = (int *) malloc(mmc * sizeof(int));
    pp->others.coincidences = (int *) malloc(pattern->k * pattern2->k * sizeof(int));
    /*for (int q=0; q<mmc; q++){
        char n[4];
        char str[20] = "others.coicidentes";
        sprintf(n, "%d", q);
        strcat(str, n);
        printf("%s",str);        //este print mostra que gerou o nome corretamente
        pp->str = (int *) malloc(mmc * sizeof(int));
        }*/
    pp->v = pattern->v;
    pp->k = pattern->k;
    pp->v = pattern2->v;
    pp->k = pattern2->k;

    /*
     * Creation of the MMC index for offset 0
     */
    
    // First pattern - aqui cria o primeiro pattern, por exemplo: 7,3 ficaria assim 1101000
        
        
        a = 0;
        b = 0;
        int menor[mmc];
        memset(menor, 0, mmc*sizeof(int));
        while (a <= mmc/pattern->v) {
            for (c=0; c < pattern->k; c++){
                menor[((pattern->onSlots[c] + a*pattern->v) % mmc)] = 1;                
                }
            a++;
        }


    // Second pattern - aqui cria o primeiro pattern, por exemplo: 9,4 ficaria assim 1100100100
    
        d = 0;
        e = 0;
        int maior[mmc];
        memset(maior, 0, mmc*sizeof(int));
        while (d < mmc/pattern2->v) {
            for (f=0; f < pattern2->k; f++){
                maior[((pattern2->onSlots[f] + d*pattern2->v) % mmc)] = 1;                
                e++;
                }
            d++;
        }
        

    // Comparation of pattern of offset 0 - aqui comprar se a posição z nos dois patterns possui o valor 1 e se positivo armazena o valor no vetor
        w=0;
        for (z=0; z < mmc; z++){
            if ((menor[z] == 1) && (maior[z]==1)){
                pp->offsetZero.coincidences[w] = z;                
                pp->offsetZero.k++;
                w++;
            }
        }
        
        
        j = 0;    
        pp->offsetZero.v = pp->v;
        for (i = 0; i < pp->offsetZero.k; i++) {
            while(j <= pp->offsetZero.coincidences[i]) {
                pp->offsetZero.index[j++] = pp->offsetZero.coincidences[i];
            }
        }
        
        while(j < pp->v) {
            pp->offsetZero.index[j++] = 0;
        }

            
            

        // Second pattern offset for different offset 0 - 
        
        int size = sizeof(maior)/sizeof(maior[0]); 
        printf("size-> %d\n", size);
        w=0;
        for (int i=1; i < 4; i++){    // i < size
            int j, last;
            last = maior[size -1];
            for (j = size-1; j >0; j--){
                maior[j] = maior[j-1];
                }
            maior[0] = last;
            }
            
        // Comparation of pattern of different offset 0    -  aqui comprar se a posição z nos dois patterns possui o valor 1 e se positivo armazena o valor no vetor, porém com um deslocamento (offset) do pattern2. Por exemplo, com offset 2 o primeiro 1 do pattern2 começa na posição 2 e como é um ciclo, os zeros finais ocupam as posições anteriores: compara 1101000 com 0011001001 
            
        k=0;
        for (t=0; t < mmc; t++){
            if ((menor[t] == 1) && (maior[t]==1)){
                pp->others.coincidences[k] = t;    //aqui deveria ser o nome others.coicidentes1[k] para offset 1,others.coicidentes2[k] para offset 2, ... 
                pp->others.k++;
                k++;
            }
        }
            
        


    return(pp);
} 

Nesta segunda comparação é que mora o problema, pois como no exemplo eu uso o mmc entre 7 e 9, este offset pode variar entre 0 e 62 (os patterns são repetidos até completar mmc posições, por exemplo, no caso do 7 ficaria 1101000 1101000 1101000 1101000 1101000...). Assim, eu preciso ter os vetores dinamicamente de acordo com o offset, pois quando eu tiver um offset, por exemplo, 11, eu tenho x coincidências entre os 1's do 7 e do 9. Como others.coincidences já é um vetor para mmc posições, pensei em apenas alterar o nome de acordo com cada offset (others.coincidences0, others.coincidences1, others.coincidences2) e depois fazer no comparation of pattern of different offset 0 algo como uma verificação se a posição [20] de others.coincidencesX for igual a t então others.coincidencesX[k] = t;

Espero que assim fique mais claro o que pretendo fazer. Desde já agradeço pela disponibilidade.

Link to post
Share on other sites
  • 0

sobre os vetores dinamicos

	//se voce declara um vetor dinamico de x posicoes voce pode acessar os elementos através dos índices
	int *v;
	v = malloc(x * sizeof(int));
	//essas são duas maneiras de acessar o indice zero
	*(v+0) = 700;
	printf("%d\n", *(v+0));
	v[0]=500;

o que é realmente importante saber é que se voce declara um ponteiro voce precisar ter espaço suficiente para guardar tudo aquilo que voce pretende, então muitas vezes é bom fazer calculos separadamente para saber se realmente estamos alocando a quantidade necessaria.

Link to post
Share on other sites
  • 0

Bom dia Herbert,

desculpa a demora, mas meu monitor queimou e fui obrigado a esperar a transportadora. Vamos ver se eu entendi: onde eu aloca as estruturas já faço o malloc 

/*
     * Allocate structures.
     */
    ...
	pp->offsetZero.index = (int *) malloc(mmc * sizeof(int));

para acessar a primeira posição eu uso offsetZero.index[0]. Se é isso eu já sabia. Meu problema seria fazer :

algo como pp->offsetZero.indexX = (int *) malloc(mmc * sizeof(int)); onde esse X do index seria um número. Desta forma eu teria:

offsetZero.index0 = com mmc posições

offsetZero.index1 = com mmc posições

offsetZero.index2 = com mmc posições

...

sendo que o X do index também varia de 0 a mmc posições.

Mudando de assunto: não sei se você já está trabalhando nesta época de isolamento social, mas se tiver tempo, estou disposto a tentar pagar por uma ajuda neste código, pois tenho um prazo curto para terminar, não gosto de programação e não sei, além de criar um bloqueio, pois tudo que faço dá erro, kkk

Se tiver interesse, me fala!   

Link to post
Share on other sites
  • 0
Em 27/07/2020 em 07:47, arcsaraiva disse:

para acessar a primeira posição eu uso offsetZero.index[0]. Se é isso eu já sabia. Meu problema seria fazer :

se você já consegue acessar o endereço daquilo que voce quer então o que falta?

vamos supor que você achou isso "offsetZero.index[0]"  e lá nessa primeira posição tem um valor,  e sse valor que será armazenado em um vetor dinamico.

ok vamos declarar o vetor dinamico

int *v;//declarei um ponteiro do mesmo tipo de dados do que os dados que vou guardar.
    v = malloc( 1 * sizeof(int));// o meu ponteiro agora tem espaço para guardar 1 inteiro
*(v+0) = offsetZero.index[0];//armazenei o primeiro valor na primeira posicao

vou guardar outro? acrescento espaço para outro inteiro e guardo ele também...

ainda tem dúvida ? ainda acha que precisa me pagar?

 

Edited by herbertbahiaa
Link to post
Share on other sites
  • 0
31 minutos atrás, herbertbahiaa disse:

vamos supor que você achou isso "offsetZero.index[0]"  e lá nessa primeira posição tem um valor,  e sse valor que será armazenado em um vetor dinamico.

o problema está aqui. Eu preciso criar, com um for ou com um while, x ponteiros. Assim eu teria offsetZero.index1[0], offsetZero.index1[1]...offsetZero.index1[62], offsetZero.index2[0], ...offsetZero.index2[62], offsetZero.index3[0],...

a minha dúvida é criar esses ponteiros. Serão mmc ponteiros com mmc elementos cada um.

35 minutos atrás, herbertbahiaa disse:

ainda tem dúvida ? ainda acha que precisa me pagar?

Todas, rsrs.

Valorizo o trabalho das pessoas, sou humilde, não tenho muito dinheiro, e não sei programar, então, se eu tiver condições, pago sim, até porque vão surgir novos problemas e novas dúvidas até que este projeto esteja pronto.

7 horas atrás, Hazzu disse:

Explique qual é o objetivo do seu programa e depois o que faz a função genPP

Hazzu,

este é um simulador de padrões de offsets. O que ele faz é criar um pré processamento para armazenar os padrões em ponteiros e depois calcular quanto tempo até um próximo padrão. Vou tentar dar um exemplo pequeno: imagine dois padrões, um com 7 elementos e desses 7, 3 são 1's e os demais 0's e um segundo padrão com 9 elementos, sendo 4 1's e os demais 0's. Matematicamente, para rodar todos os possíveis offsets, eu preciso do mmc dos dois padrões, neste caso 63. Então visualmente eu tenho:

1º - 1101000 1101000 1101000 1101000...

2º - 110010010 110010010 110010010 110010010...

Neste exemplo, repetindo cada sequência mmc vezes tenho a coincidência dos 1's em 12 posições. No main eu faço o sorteio de uma posição start e dela é calculado quanto tempo até a primeira coincidência de 1's.

Repare que neste primeiro exemplo o offset entre os dois padrões é 0. Depois eu preciso andar com esse padrão mmc vezes. Por exemplo com offset 1 a sequência fica assim:

1º - 1101000 1101000 1101000 1101000...

2º - 0 110010010 110010010 110010010 11001001...

Sempre o segundo padrão que desloca e é um ciclo, logo, o último elemento [62] passa para a primeira posição.

O pré-processamento é justamente isso. Ele armazena as coincidências quando existe o casamento dos 1's dos dois padrões e no index ele já armazena qual a próxima coincidência.

Então no exemplo do offset 0, o elemento 0 aponta para 0, o elemento 1 aponta para 1, os elementos 2 ao 10 apontam para o 10...

Espero ter explicado.

A função genPP nada mais é que a função gerador de padrões de pontos (genPP) que gera os padrões e os offsets. E nela que preciso alterar para armazenar as coincidências e os indexs.

 

Link to post
Share on other sites
  • 0

o que é

t_pp_bd

É uma struct? que isso?

você tem novos tipos de dados por todos os lados e n sabemos que são int char ou outras coisas

Link to post
Share on other sites
  • 0

Esse seu código está massivo e complexo. Pelo o que entendi do problema, seria melhor utilizar a lógica de vetores circulares e matrizes (vetores de ponteiros). Também não entendi por que você fará MMC offsets, visto que a partir do offset L2 o padrão volta a se repetir (L2 é o comprimento do segundo padrão).

11 horas atrás, arcsaraiva disse:

2º - 110010010 110010010 110010010 110010010... (0)
2º - 0 110010010 110010010 110010010 11001001...(1)
2º - 10 110010010 110010010 110010010 1100100... (2)
2º - 010 110010010 110010010 110010010 110010...(3)
2º - 0010 110010010 110010010 110010010 11001...(4)
2º - 10010 110010010 110010010 110010010 1100...(5)
2º - 010010 110010010 110010010 110010010 110...(6)
2º - 0010010 110010010 110010010 110010010 11...(7)

2º - 10010010 110010010 110010010 110010010 1...(8)
2º - 110010010 110010010 110010010 110010010...(9)

No offset 9 a posição inicial já volta a se repetir.

 

Se estiver disposto me explicar direito o que exatamente você precisa fazer, do início ao fim, posso te guiar pela melhor solução (vamos reconstruir o código completo).
Contato: Hazzu#7444 (Discord).

Edited by Hazzu
Link to post
Share on other sites
  • 0

Impossível!

Porque essas varáveis ao seu modo são identificadores membros da estrutura,  e só é permitido ser assim quando declaradas junto a estrutura (struct).

 

Pode declara um membro de variável indexável flexível, mas acredito que ainda não é o que procura, contudo é o mais próximo que as especificações permite alcançar o que deseja.

Edited by britivaldo
Link to post
Share on other sites
  • 0
Em 28/07/2020 em 19:50, Hazzu disse:

Esse seu código está massivo e complexo. Pelo o que entendi do problema, seria melhor utilizar a lógica de vetores circulares e matrizes (vetores de ponteiros). Também não entendi por que você fará MMC offsets, visto que a partir do offset L2 o padrão volta a se repetir (L2 é o comprimento do segundo padrão).

 

Se estiver disposto me explicar direito o que exatamente você precisa fazer, do início ao fim, posso te guiar pela melhor solução (vamos reconstruir o código completo).
Contato: Hazzu#7444 (Discord).

Olá Hazzu,

quanto a reconstruir o código completo eu não posso, pois a única função que posso alterar é o genPP.

Essa função recebe por parâmetros informações como dois padrões (compostos por total de slots, slots ativos) e o mmc.

no First pattern o que eu faço é pegar o primeiro padrão, por exemplo, 7,3 e faço ele se repetir mmc (entre os dois padrões) vezes, logo no exemplo 7,3 sem repetição eu teria 1101000, já com repetição é só repetir ele 9 vezes.

no second pattern eu faço a mesma coisa para o segundo padrão, por exemplo, 9,4. Logo sem repetição fica 1100100100, já com repetição é só repetir esse padrão 7 vezes.

No comparation of pattern of offset 0 eu simplesmente comparo se os 1's dos dois padrões tem coincidências de localização e armazeno no offsetZero.coincidences e depois eu armazeno para os 0's qual é a próxima coincidência. Vou fazer um exemplo:

padrão 7,3 => 110100011010001101000110100011010001101000110100011010001101000

padrão 9,4 = >110010010110010010110010010110010010110010010110010010110010010

offsetZero.coincidences[0]=0

offsetZero.coincidences[1]=1

offsetZero.coincidences[2]=7

offsetZero.coincidences[3]=10

offsetZero.coincidences[4]=22

....

offsetZero.index[0]=1

offsetZero.index[1]=1

offsetZero.index[2]=7

offsetZero.index[3]=7

offsetZero.index[4]=7

offsetZero.index[[5]=7

offsetZero.index[6]=7

offsetZero.index[7]=7

offsetZero.index[8]=10

offsetZero.index[[9]=10

offsetZero.index[10]=10

offsetZero.index[[11]=22

...

O problema está no second pattern offset for diefferent offset 0. 

Aqui é deslocado todo o segundo parttern até mmc vezes, então, por exemplo:

offset 0

110100011010001101000110100011010001101000110100011010001101000

110010010110010010110010010110010010110010010110010010110010010

offset 1

110100011010001101000110100011010001101000110100011010001101000

011001001011001001011001001011001001011001001011001001011001001

offset 2

110100011010001101000110100011010001101000110100011010001101000

101100100101100100101100100101100100101100100101100100101100100

offset 3

110100011010001101000110100011010001101000110100011010001101000

010110010010110010010110010010110010010110010010110010010110010

...

Você pode perceber que o ultimo elemento retorna na primeira posição de forma circular. O que não sei fazer é armazenar os others.coicidences e orther.index para cada offset.

Eu tentei criar mmc others.coicidences e others.index, através de um for, mas não funcionou e meu professor me deu a dica de vetores dinâmicos, mais não entendi bem como fazer.

Se olhar com calma, a coincidência do offset 1  é diferente dos demais e logo os index também serão. O mesmo comportamento acontece com todos os demais offsets.

Espero ter explicado melhor. Resumidamente eu preciso alterar estas linhas (eu acho):

pp->others.coincidences = (int *) malloc(pattern->k * pattern2->k * sizeof(int));
pp->others.index = (int *) malloc(mmc * sizeof(int));

Para fazer com que sejam vetores dinâmicos, e alterar o second pattern offset for diefferent offset 0 para armazenar a cada offset várias coincidências e mmc index.

8 horas atrás, britivaldo disse:

Impossível!

Porque essas varáveis ao seu modo são identificadores membros da estrutura,  e só é permitido ser assim quando declaradas junto a estrutura (struct).

 

Pode declara um membro de variável indexável flexível, mas acredito que ainda não é o que procura, contudo é o mais próximo que as especificações permite alcançar o que deseja.

Acredito que seja possível com vetores dinâmicos, pelo menos foi isto que meu professor indicou.

Link to post
Share on other sites
  • 0
Em 28/07/2020 em 10:54, vangodp disse:

o que é

t_pp_bd

É uma struct? que isso?

você tem novos tipos de dados por todos os lados e n sabemos que são int char ou outras coisas

Olá vangodp, sim, t_pp_bd é um struct. Mais acima tentei explicar com detalhes o que este código faz. Qualquer dúvida estou as ordens.

 

Link to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Answer this question...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Cloud Computing


  • Forum Statistics

    • Total Topics
      148680
    • Total Posts
      644501
×
×
  • Create New...