Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Fare eseguire a tutti gli oggetti di un tipo la stessa azione
Forum - C/C++ - Fare eseguire a tutti gli oggetti di un tipo la stessa azione

Avatar
Gioviok (Normal User)
Newbie


Messaggi: 7
Iscritto: 26/03/2016

Segnala al moderatore
Postato alle 20:39
Mercoledì, 30/03/2016
Volevo sapere se era possibile, dati degli oggetti dello stesso tipo, far eseguire tutti loro una azione contemporaneamente, senza farlo ad uno ad uno.
Per esempio
Codice sorgente - presumibilmente C++

  1. class un_oggetto(int a){
  2. public:
  3. int r = a;
  4. void ritornaqualcosa(){
  5. cout << r << endl;
  6. }
  7. };
  8. int main(){
  9. un_oggetto a(1);
  10. un_oggetto b(2);
  11. un_oggetto c(3);
  12. un_oggetto d(4);
  13. un_oggetto e(5);
  14. un_oggetto f(6);
  15. //da qui...
  16. a.ritornaqualcosa();
  17. b.ritornaqualcosa();
  18. c.ritornaqualcosa();
  19. d.ritornaqualcosa();
  20. f.ritornaqualcosa();
  21. //a qui
  22. //vorrei semplificare
  23. return 0;
  24. }



Si può fare in qualche modo?
Grazie in anticipo!:k:

Ultima modifica effettuata da Gioviok il 30/03/2016 alle 20:40


Mmm...una struttura nuda...
PM Quote
Avatar
lumo (Member)
Expert


Messaggi: 414
Iscritto: 18/04/2010

Segnala al moderatore
Postato alle 21:48
Mercoledì, 30/03/2016
Sì, usa un array e un for.

PM Quote
Avatar
nessuno (Normal User)
Guru^2


Messaggi: 5475
Iscritto: 03/01/2010

Segnala al moderatore
Postato alle 22:14
Mercoledì, 30/03/2016
Naturalmente saranno sempre attivati in sequenza, non contemporaneamente, ma bisogna capire meglio cosa intendi...


Ricorda che nessuno è obbligato a risponderti e che nessuno è perfetto ...
PM Quote
Avatar
AldoBaldo (Member)
Expert


Messaggi: 346
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 15:46
Giovedì, 31/03/2016
Potresti anche realizzare una classe che comprenda l'array e lo gestisca "in automatico", con un metodo .FaiQuestoEQuello() che comprenda, senza "rivelarlo", il for al quale ha accennato lumo.

Ultima modifica effettuata da AldoBaldo il 31/03/2016 alle 15:46


Ma cosa vuoi che ne sappia? Io ci gioco, col codice, mica ci lavoro!
PM Quote
Avatar
AldoBaldo (Member)
Expert


Messaggi: 346
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 16:43
Giovedì, 31/03/2016
Ora mi faccio pigliare un po' per i fondelli dai "guru" del forum... :rofl:

In un file "un_oggetto.h":

Codice sorgente - presumibilmente C++

  1. #ifndef UN_OGGETTO_H
  2. #define UN_OGGETTO_H
  3.  
  4. #include <stdio.h>
  5.  
  6. // il tuo oggetto d'esempio (piu' o meno)
  7.  
  8. class un_oggetto {
  9.     public:
  10.         un_oggetto( int valore = 0 ) { v = valore; }
  11.  
  12.         void imposta( int valore ) { v = valore; }
  13.         void visualizza() { printf( "%d\n", v ); }
  14.  
  15.     private:
  16.         int v;
  17. };
  18.  
  19. #endif // UN_OGGETTO_H



In un file "oggetti_in_serie.h":

Codice sorgente - presumibilmente C++

  1. #ifndef OGGETTI_IN_SERIE_H
  2. #define OGGETTI_IN_SERIE_H
  3.  
  4. #include "un_oggetto.h"
  5.  
  6.  
  7. class oggetti_in_serie {
  8.     public:
  9.         oggetti_in_serie( int nOggetti = 1 );
  10.         virtual ~oggetti_in_serie();
  11.  
  12.         void imposta_tutti( int valore );
  13.         void imposta_in_serie( int inizio = 1 );
  14.         void imposta( int indice, int valore );
  15.         void visualizza();
  16.         void visualizza( int indice );
  17.  
  18.     private:
  19.         int n;
  20.         un_oggetto *s;
  21.  
  22.         oggetti_in_serie(const oggetti_in_serie& other);
  23.         oggetti_in_serie& operator=(const oggetti_in_serie& rhs);
  24. };
  25.  
  26. #endif // OGGETTI_IN_SERIE_H



In un file "oggetti_in_serie.cpp":

Codice sorgente - presumibilmente C++

  1. #include "oggetti_in_serie.h"
  2.  
  3. /*==============================================================================
  4. Crea in memoria dinamica un array di oggetti di tipo un_oggetto contenente
  5. nOggetti elementi (nOggetti, per default, e' impostato su 1). Tutti gli oggetti
  6. nell'array vengono "azzerati".
  7. ==============================================================================*/
  8.  
  9. oggetti_in_serie::oggetti_in_serie( int nOggetti ) {
  10.     s = new un_oggetto[nOggetti];
  11.     n = nOggetti;
  12.     imposta_tutti( 0 );
  13. }
  14.  
  15. /*==============================================================================
  16. Libera la memoria dinamica abbinata all'oggetto che stiamo distruggendo.
  17. ==============================================================================*/
  18.  
  19. oggetti_in_serie::~oggetti_in_serie() {
  20.     delete[] s;
  21. }
  22.  
  23. /*==============================================================================
  24. Imposta tutti gli oggetti della serie sul valore passato tramite il parametro.
  25. ==============================================================================*/
  26.  
  27. void oggetti_in_serie::imposta_tutti( int valore ) {
  28.     for( int i=0; i<n; ++i )
  29.         s[i].imposta( valore );
  30. }
  31.  
  32. /*==============================================================================
  33. Imposta gli oggetti della serie su valori progressivi a partire da quello
  34. specificato tramite il parametro.
  35. ==============================================================================*/
  36.  
  37. void oggetti_in_serie::imposta_in_serie( int inizio ) {
  38.     for( int i=0; i<n; ++i )
  39.         s[i].imposta( inizio++ );
  40. }
  41.  
  42. /*==============================================================================
  43. Imposta l'oggetto all'indice specificato sul valore passato tramite il parametro.
  44. Se l'indice riguarda un oggetto non compreso entro i limiti della serie, il
  45. metodo non fa nulla.
  46. ==============================================================================*/
  47.  
  48. void oggetti_in_serie::imposta( int indice, int valore ) {
  49.     if( indice >= 0 && indice < n )
  50.         s[indice].imposta( valore );
  51. }
  52.  
  53. /*==============================================================================
  54. Richiama il metodo "visualizza" per ciascuno degli oggetti nella serie.
  55. ==============================================================================*/
  56.  
  57. void oggetti_in_serie::visualizza() {
  58.     for( int i=0; i<n; ++i )
  59.         s[i].visualizza();
  60. }
  61.  
  62. /*==============================================================================
  63. Richiama il metodo "visualizza" per l'oggetto all'indice specificato.
  64. Se l'indice riguarda un oggetto non compreso entro i limiti della serie, il
  65. metodo non fa nulla.
  66. ==============================================================================*/
  67.  
  68. void oggetti_in_serie::visualizza( int indice ) {
  69.     if( indice >= 0 && indice < n )
  70.         s[indice].visualizza();
  71. }
  72.  
  73. /*==============================================================================
  74. Costruttore di copia e operatore di assegnamento sono resi indisponibili da
  75. questi metodi "fantasma".
  76. ==============================================================================*/
  77.  
  78. oggetti_in_serie::oggetti_in_serie(const oggetti_in_serie& other) {
  79.     //copy ctor
  80. }
  81.  
  82. oggetti_in_serie& oggetti_in_serie::operator=(const oggetti_in_serie& rhs) {
  83.     if (this == &rhs) return *this; // handle self assignment
  84.     //assignment operator
  85.     return *this;
  86. }



Dopo tutta 'sta roba, il file "main.cpp" si può semplificare così:

Codice sorgente - presumibilmente C/C++

  1. #include "oggetti_in_serie.h"
  2.  
  3. int main() {
  4.     oggetti_in_serie s( 150 );
  5.  
  6.     s.imposta_in_serie();
  7.     s.visualizza();
  8.  
  9.     return 0;
  10. }



Chi volesse lanciarmi qualche sfottò farebbe solo bene.

Ultima modifica effettuata da AldoBaldo il 31/03/2016 alle 17:32


Ma cosa vuoi che ne sappia? Io ci gioco, col codice, mica ci lavoro!
PM Quote
Avatar
lumo (Member)
Expert


Messaggi: 414
Iscritto: 18/04/2010

Segnala al moderatore
Postato alle 18:44
Giovedì, 31/03/2016
Più che altro sei sicuro che copia e assegnamento siano implementati giusti?
Detto questo, vedere memoria allocata esplicitamente in C++ mi fa venire la voglia compulsiva di gestire l'array a compile time usando template programming avanzato.
(Oppure una tupla ma chi lo sa il C++ nuovo)

PM Quote
Avatar
AldoBaldo (Member)
Expert


Messaggi: 346
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 8:38
Venerdì, 01/04/2016
Copia e assegnamento li ho "neutralizzati" perché non m'andava di star lì a mettere insieme anche quelli (un bel gioco dura poco). Essendo privati tentare di usarli dà un bell'errore e ti blocca evitando pasticci peggiori, tanto nel contesto di quel che ho fatto non servono.

I template li uso di rado, perché mi danno ancora qualche grattacapo. Ho capito cosa sono e come funzionano, ma per poterne trarre vantaggio devo ragionarci un po' su e non sempre ne ho voglia. Comunque riconosco che in alcune situazioni m'hanno aiutato a "far fuori" paginate e paginate di roba. In altre m'ha semplicemente aiutato ad autoumiliarmi.

Una tupla non sapevo neanche cosa fosse, così ho cercato di documentarmi con wikipedia. Là son stati talmente chiari da farmi pensare che sarebbe stato meglio andare su cplusplus.com, e l'ho fatto. Dopo non averci capito niente per la seconda volta son costretto ad andar fiero di continuare a non saperne nulla. Capirai, il mio riferimento per il C++ è tutt'ora un libro del 1996, sono giurassico! :heehee: Però almeno su quello mi oriento a dovere perché è scritto con la chiara intenzione di spiegare le cose.


Ma cosa vuoi che ne sappia? Io ci gioco, col codice, mica ci lavoro!
PM Quote
Avatar
Gioviok (Normal User)
Newbie


Messaggi: 7
Iscritto: 26/03/2016

Segnala al moderatore
Postato alle 19:27
Lunedì, 04/04/2016
Grazie a tutti per le risposte! :k:


Mmm...una struttura nuda...
PM Quote