C/C++ - Fare eseguire a tutti gli oggetti di un tipo la stessa azione

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

class un_oggetto(int a){
public:
int r = a;
void ritornaqualcosa(){
cout << r << endl;
}
};
int main(){
un_oggetto a(1);
un_oggetto b(2);
un_oggetto c(3);
un_oggetto d(4);
un_oggetto e(5);
un_oggetto f(6);
//da qui...
a.ritornaqualcosa();
b.ritornaqualcosa();
c.ritornaqualcosa();
d.ritornaqualcosa();
f.ritornaqualcosa();
//a qui
//vorrei semplificare
return 0;
}

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

Sì, usa un array e un for.

Naturalmente saranno sempre attivati in sequenza, non contemporaneamente, ma bisogna capire meglio cosa intendi...

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.

Ora mi faccio pigliare un po' per i fondelli dai "guru" del forum...

In un file "un_oggetto.h":

#ifndef UN_OGGETTO_H
#define UN_OGGETTO_H

#include <stdio.h>

// il tuo oggetto d'esempio (piu' o meno)

class un_oggetto {
    public:
        un_oggetto( int valore = 0 ) { v = valore; }

        void imposta( int valore ) { v = valore; }
        void visualizza() { printf( "%d\n", v ); }

    private:
        int v;
};

#endif // UN_OGGETTO_H

In un file "oggetti_in_serie.h":

#ifndef OGGETTI_IN_SERIE_H
#define OGGETTI_IN_SERIE_H

#include "un_oggetto.h"


class oggetti_in_serie {
    public:
        oggetti_in_serie( int nOggetti = 1 );
        virtual ~oggetti_in_serie();

        void imposta_tutti( int valore );
        void imposta_in_serie( int inizio = 1 );
        void imposta( int indice, int valore );
        void visualizza();
        void visualizza( int indice );

    private:
        int n;
        un_oggetto *s;

        oggetti_in_serie(const oggetti_in_serie& other);
        oggetti_in_serie& operator=(const oggetti_in_serie& rhs);
};

#endif // OGGETTI_IN_SERIE_H

In un file "oggetti_in_serie.cpp":

#include "oggetti_in_serie.h"

/*==============================================================================
Crea in memoria dinamica un array di oggetti di tipo un_oggetto contenente
nOggetti elementi (nOggetti, per default, e' impostato su 1). Tutti gli oggetti
nell'array vengono "azzerati".
==============================================================================*/

oggetti_in_serie::oggetti_in_serie( int nOggetti ) {
    s = new un_oggetto[nOggetti];
    n = nOggetti;
    imposta_tutti( 0 );
}

/*==============================================================================
Libera la memoria dinamica abbinata all'oggetto che stiamo distruggendo.
==============================================================================*/

oggetti_in_serie::~oggetti_in_serie() {
    delete[] s;
}

/*==============================================================================
Imposta tutti gli oggetti della serie sul valore passato tramite il parametro.
==============================================================================*/

void oggetti_in_serie::imposta_tutti( int valore ) {
    for( int i=0; i<n; ++i )
        s[i].imposta( valore );
}

/*==============================================================================
Imposta gli oggetti della serie su valori progressivi a partire da quello
specificato tramite il parametro.
==============================================================================*/

void oggetti_in_serie::imposta_in_serie( int inizio ) {
    for( int i=0; i<n; ++i )
        s[i].imposta( inizio++ );
}

/*==============================================================================
Imposta l'oggetto all'indice specificato sul valore passato tramite il parametro.
Se l'indice riguarda un oggetto non compreso entro i limiti della serie, il
metodo non fa nulla.
==============================================================================*/

void oggetti_in_serie::imposta( int indice, int valore ) {
    if( indice >= 0 && indice < n )
        s[indice].imposta( valore );
}

/*==============================================================================
Richiama il metodo "visualizza" per ciascuno degli oggetti nella serie.
==============================================================================*/

void oggetti_in_serie::visualizza() {
    for( int i=0; i<n; ++i )
        s[i].visualizza();
}

/*==============================================================================
Richiama il metodo "visualizza" per l'oggetto all'indice specificato.
Se l'indice riguarda un oggetto non compreso entro i limiti della serie, il
metodo non fa nulla.
==============================================================================*/

void oggetti_in_serie::visualizza( int indice ) {
    if( indice >= 0 && indice < n )
        s[indice].visualizza();
}

/*==============================================================================
Costruttore di copia e operatore di assegnamento sono resi indisponibili da
questi metodi "fantasma".
==============================================================================*/

oggetti_in_serie::oggetti_in_serie(const oggetti_in_serie& other) {
    //copy ctor
}

oggetti_in_serie& oggetti_in_serie::operator=(const oggetti_in_serie& rhs) {
    if (this == &rhs) return *this; // handle self assignment
    //assignment operator
    return *this;
}

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

#include "oggetti_in_serie.h"

int main() {
    oggetti_in_serie s( 150 );

    s.imposta_in_serie();
    s.visualizza();

    return 0;
}

Chi volesse lanciarmi qualche sfottò farebbe solo bene.

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)

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! Però almeno su quello mi oriento a dovere perché è scritto con la chiara intenzione di spiegare le cose.

Grazie a tutti per le risposte!