Olá…
Tenho um array de structs em C++ que aloco dinamicamente…
Tipo, começo alocando 10 posições e vou alocando mais 10 cada vez que acaba…
minha dúvida é:
Tem alguma função que me retorne quantas posições tem este array?
segue exemplo de como estou alocando.
if (qtdMaxMed == 0)
{
nfe->infNFe.det[qtdDet].prod.med = new med[10];
memset(nfe->infNFe.det[qtdDet].prod.med,0,sizeof(med)*10);
qtdMaxMed = 10;
}
if (qtdMed == qtdMaxMed-1)
{
med *listaAuxMed = new med[qtdMaxMed+10];
memset(listaAuxMed,0,sizeof(med)*(qtdMaxMed+10));
memcpy(listaAuxMed, nfe->infNFe.det[qtdDet].prod.med, sizeof(med)*qtdMaxMed);
delete [] nfe->infNFe.det[qtdDet].prod.med;
nfe->infNFe.det[qtdDet].prod.med = listaAuxMed;
qtdMaxMed+=10;
}
Ps: sei que tenho esse numero nas variáveis, mas vou precisar percorrer este array em outra função (onde não tenho essas variáveis) depois de preenchida.
Amigo, evite ao máximo usar esse tipo de coisas - use um std::vector, que:
a) Tem exatamente a mesma velocidade de um array normal do C++ se for compilado em modo “Release”;
b) Tem esse controle de alocação e desalocação que você está tentando fazer manualmente.
c) Retorna a quantidade de elementos de forma simples - usando o método “size()”
Obviamente, você só precisa tomar cuidado com o seguinte: quando for passar um std::vector para outro método, use um const std::vector& (se o vetor for apenas para ser consultado pelo outro método) ou um std::vector& (se o vetor tiver de ser alterado pelo outro método).
E outra coisa. Você sabe que em C++,
Um array alocado é exatamente como se fosse um ponteiro. Portanto, não é possível o outro método saber qual é a quantidade de elementos alocada nesse array. É que o C++ não deixa você saber qual é o tamanho da memória alocada para esse array de forma simples e imediata, já que cada compilador faz isso de um jeito e pode até mudar o esquema, dependendo da arquitetura, modo de compilação e outras coisas. Ou seja, não dá para saber quantos elementos tem o array, sem passar um segundo parâmetro que diz quantos elementos tem esse array.
(Em C99 acho que é possível saber o número de elementos do array, mas aí esse array com tamanho não é a mesma coisa que um ponteiro, e a sintaxe é completamente incompatível com C++. Portanto, mesmo que seu compilador suporte C99, não dá para fazer do jeito que você quer sem ter de mudar muita coisa.)
Para um código C++, isso aí tem muito mal cheiro de C.
Por exemplo, o que é aquele delete medonho ali?
Dica. Largue mão das structs e comece a trabalhar corretamente com classes e seus destrutores.
C++ é uma linguagem perigosa. Ele te dá muito poder, mas te põe no meio de um campo minado. Sem muito cuidado e organização de sua parte, você acaba explodindo.
Esse tipo de código que você escreveu também tem cheiro de “vai dar pau em algum copy&paste que fizer errado ou que fizer a manutenção errado”.
É que a parte de alocação e redimensionamento de um array não está segregada em um método separado, mais abstrato.
Está dentro do código principal, pelo que imagino pelos nomes das variáveis, então com certeza vai acabar dando algum pau de copy & paste - você corrige um bug em um ponto do seu código, mas não consegue corrigir o mesmo bug em todos os pontos, já que esse mesmo código, só que com nomes de variáveis diferentes (e com valores de acréscimo diferentes) vai estar espalhado por 100 arquivos .cpp dentro de seu programa.
Bom pessoal…
primeiramente agradeço os conselhos…
“segundamente”, vcs me assustaram… hehehehe
Mas por se tratar de um programinha pequeno e simples, (só vou ler os dados de um arquivo texto para preencher as struct e reescrever estes dados das structs num outro arquivo texto), não vai valer a pena eu reescrever tudo… vou assumir os riscos citados por vcs, pelo menos por enquanto.
mesmo assim obrigado mesmo pela atenção!!
abraços!
[quote=Schuenemann][quote=ViniGodoy]Para um código C++, isso aí tem muito mal cheiro de C.
Por exemplo, o que é aquele delete medonho ali? [/quote]
Como seria melhor?[/quote]
Cedo ou tarde iria ocorrer um delete, lógico. Mas, quem deve ser o responsável por dá-lo?
Geralmente seria o destrutor de alguma classe, muito próxima do objeto em questão (provavelmente na classe do objeto prod).
Ou, se você estiver usando a boost, um smart pointer.
Mas, como ele está usando structs, o código acaba ficando disperso e orientado a dados, como era comum na época do C.
