Prob C++

Voilà, j’ai un programme qui me pose problème :
A partir d’un fichier donné (généré par un autre programme), je me
retrouve à lire environ 500x864 positions et vitesses (donc encore x6,
et le environ c’est parce que le 500 est arbitraire). Ca fait quand
même pas mal de données à traiter… Le but, c’est de calculer une
intégrale sur les vitesses (les positions sont pout un autre calcul).

Mon idée : une classe lit le fichier, enregistre
le tout dans deux vecteurs, et envoye l’adresse de ces vecteurs à la
classe chargée de les traiter. Je me retrouve donc avec vector * v à traiter.

Mon problème : c’est sûrement très simple, bête et méchant, mais
je trouve pas comment accéder à l’élément “k” de ce vecteur pour
l’utiliser; je vois partout sur Internet qu’on est censé pouvoir utiliser la
fonction at() qui est plus sûre que l’opérateur [], mais si elle fonctionne bien pour les string par
exemple, elle semble inexistante pour les vecteurs : no matching function for call to `vector<double,allocator >::at (int)’

Je mets un bout de code (simplifié au niveau des calculs) pour l’exemple :

class Reader {

vector * getVelocities();

}

class Velocity {

vector * v;

}

double Velocity::avaf(int p, int atom, int time, int t) {

return (v->at(3*(nattime+atom)+p) * v->at(3(nat*(time+t)+atom)+p));

}

void Velocity::calculate(int nat, int nos, double dt, vector * veloc) {

v = veloc;

cout << avaf(0, 1, 0, 0)<< endl;

}

int main(…) {

Reader r; Velocity v;

v.calculate(864, 500, 0.05, r.getVelocities());

}

Quelqu’un pourrait-il m’aider siouplait? Soit avec la solution (et
après en avoir vu la simplicité je vais certainement pouvoir me jeter
par la fenêtre, à moins que ce soit un fichier manquant de mon compilo g++), soit avec une idée d’une meilleure approche du
problème (mais là aussi par la fenêtre après avoir passé un après-midi
là-dessus )

bah en fait, si on parle bien du Vector de la STL, je ne connais pas de méthode at.

qui plus est, dans le cadre de la STL toujours, c’est dommage d’aller farfouiller dans ton tableau à la main alors que les itérateurs le font très bien pour toi mais je ne pense pas qu’il y ait pour autant de contre-indications particulières pour l’utilisation de l’opérateur [].

[quote]bah en fait, si on parle bien du Vector de la STL, je ne connais pas de méthode at.

qui
plus est, dans le cadre de la STL toujours, c’est dommage d’aller
farfouiller dans ton tableau à la main alors que les itérateurs le font
très bien pour toi mais je ne pense pas qu’il y ait pour autant de
contre-indications particulières pour l’utilisation de l’opérateur [].[/quote]
Oui, je parle bien de la STL (j’avais d’ailleurs écrit
en plus dans le titre pour faire moins générique, mais forcément j’ai
oublié de convertir les < > en html).
En fait j’utilise pour la première fois réellement la STL (en
passant sur un thread à propos du cryptage j’ai été convaincu de
l’utiliser), et je connais pas très bien toutes les méthodes…
T’aurais pas un petit bout de code à me montrer que je comprenne comment calculer
v[i] * v[j] (avec les itérateurs ou ce que tu veux) ?

C’est bon !
Merci pour le coup des itérateurs, j’ai fait une recherche rapide et trouvé seul la réponse (et ça semble jouer) :

double Velocity::avaf(int p, int atom, int time, int t) {

double rvalue;

vector::iterator access = v->begin() + 3 * (nat * time + atom) + p;

rvalue = *access;

access = v->begin() + 3 * (nat * (time + t) + atom) + p;

rvalue *= *access;

return (rvalue);

}

Pourquoi utilises-tu toujours begin() ? L’idée de base avec les iterator c’est :

std::vector coucou;

std::vector::iterator i;

for(i = coucou.begin(): i != coucou.end(): ++i) {

.: la valeur du ieme element est (*i) :.

}

Ce message a été édité par Drealmer le 12/01/2004

[quote]Pourquoi utilises-tu toujours begin() ?

Parce que je connais pas encore bien la STL

L’idée de base avec les iterator c’est :

std::vector coucou;

std::vector::iterator i;

for(i = coucou.begin(): i != coucou.end(): ++i) {

.: la valeur du ieme element est (*i) :.

}

Ce message a été édité par Drealmer le 12/01/2004[/quote]
Je comprends pas l’utilité d’une boucle pour n’accéder qu’à 2 éléments
sur 3x864 ? Par contre, je viens de me rendre compte que je peux
simplifier mon code, puisque en gros j = i+t, donc un seul begin()

Ok ok j’ai rien dit, j’avais ma lu ta question… Là j’expliquais la méthode pour tout parcourir. Par contre, utiliser begin() et ajouter des trucs derrière comme on ferait avec un pointeur c’est pas comme ça que je le ferai. Le mieux c’est tout de même d’utiliser [] pour indicer le vecteur.

Pour ce qui est de at() j’ai déjà lu ça, mais j’ai jamais utilisé… Tout ce que j’en retiens, c’est que at() fait un check pour vérifier qu’on dépasse pas les limites du container, alors que [] n’en fait pas. En gros si c’est bien codé, at() ne sert à rien

Pas grave pour le coup de la boucle, je t’en veux pas
Par contre j’en reviens quand même à ce qui me pose problème : j’ai
jamais réussi à me mettre dans ma pauvre petite tête (ou alors j’ai su
et ai oublié, ça fait un moment que j’ai plus vraiment touché au C++)
comment on utilise [] avec un pointeur (c’est le pourquoi du at() : là
je savais qu’il aurait simplement fallu écrire v->at(…)) ? Ca doit
être un truc à la con avec les :: voire plus simple encore, mais un
exemple me ferait du bien peu importe que ce soit avec itérateurs ou [] ou que sais-je encore

Ce message a été édité par Baleg le 12/01/2004

bah normalement, quand c’est bien fait, tu fait juste : bob  = maliste[elementn] + 12 - 43 + lageducapitaine… avec maliste en vecteur et elementn, l’index de l’element…

Enfin en meme temps, moi la STL et le C++ : ca va mais de loin

Bon, pour ton soucis, tu peux utiliser “at”, tel que suit :

std::vector MonVector;

std::vector *pPointerSurMonVector = &MonVector;

pPointerSurMonVector->at(nIndex);

Sinon, si ça ne marche pas, c’est que ta version des STL est trop ancienne ou ne suit pas la norme a priori. Tu peux donc essayer d’utiliser l’operateur [] tel que suit :

(*pPointerSurMonVector)[nIndex];[/quote]et voilou. Testé et approuvé avec VS.NET 2003 [img]style_emoticons/<#EMO_DIR#>/smile.gif[/img] Les autres compilateur je sais pas [img]style_emoticons/<#EMO_DIR#>/smile.gif[/img]

[quote]Bon, pour ton soucis, tu peux utiliser “at”, tel que suit :

std::vector MonVector;

std::vector *pPointerSurMonVector = &MonVector;

pPointerSurMonVector->at(nIndex);

Sinon, si ça ne marche pas, c’est que ta version des STL est
trop ancienne ou ne suit pas la norme a priori. Tu peux donc essayer
d’utiliser l’operateur [] tel que suit :

(*pPointerSurMonVector)[nIndex];[/quote]et voilou. Testé et approuvé avec VS.NET 2003 [img]style_emoticons/<#EMO_DIR#>/smile.gif[/img] , merci à tous pour vos contributions !!!