For para gerar nomes de ponteiros

[arcsaraiva 0]

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?

 

[herbertbahiaa 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

 

[arcsaraiva 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.

[herbertbahiaa 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.

[arcsaraiva 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!   

[Hazzu 0]

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

[herbertbahiaa 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 July 28, 2020 by herbertbahiaa

[arcsaraiva 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.

 

[vangodp 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

[Hazzu 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 July 28, 2020 by Hazzu

[britivaldo 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 July 30, 2020 by britivaldo

[arcsaraiva 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.

[arcsaraiva 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.