La creación de un estándar de la cola de los punteros en c++

Decir que tengo una cola de enteros,

#include <iostream>
#include <queue>
using namespace std;


int main() {

    int firstValToBePushed = 1;

    queue<int> CheckoutLine;

    CheckoutLine.push(firstValeToBePushed);

    cout << CheckoutLine.front();

    return 0;
}

¿Cómo puedo hacer esencialmente lo mismo usar una cola que contiene punteros a enteros frente a los números enteros como se hace actualmente por encima. He pensado en hacer un bucle para hacer más de un valor, pero esto es sólo una más simple ejemplo.

Gracias,

  • ¿Cuál es su último requisito de la necesidad de un puntero a entero? Tan lejos como las definiciones de ir, queue<int*> CheckoutLine; es lo que quieres.
  • Como @KarthikT dicho, depende altamente de su tarea. La pregunta es, ¿qué piensa utilizar punteros para? ¿Desea asignar dinámicamente y eliminar los enteros se almacenan en la cola? Recuerde, el tamaño de int es igual al tamaño de puntero, así que usted no pierde ningún espacio por el paso de los números enteros directamente.
  • Finalmente me quiere tomar estos punteros que se hace referencia a objetos de una clase, almacenarlos en la cola, a continuación, tienen la capacidad de moverse fuera de la cola de una lista. He utilizado enteros en el ejemplo de arriba, porque son las más sencillas para el bien de esta pregunta.
  • El tipo de objeto es relativamente irrelevante. Usted no necesita consejos para que cualquiera, y desde su descripción hasta el momento usted no debe usar punteros aquí.
InformationsquelleAutor Joe Elder | 2012-12-06

4 Kommentare

  1. 4

    Si que es para la administración del ciclo de vida, entonces:

    std::queue<std::shared_ptr<int>> CheckoutLine;
    CheckoutLine.push(std::make_shared<int>(firstValeToBePushed))

    Si su cola es como un proxy, y alguien es dueño de la vida útil de los objetos, entonces definitivamente:

    std::queue<std::reference_wrapper<int>> CheckoutLine;
    CheckoutLine.push(firstValeToBePushed)

    Si no exponga la cola en cualquier lugar y es interno, , a continuación, almacenar punteros está bien, como otros sugirieron.

    Sin embargo, NUNCA exponer a un cliente de una colección de punteros, que es lo peor que uno puede hacer como dejar la carga de la gestión de la vida en ellos, y que el desordenado en las colecciones.

    De curso para los tipos primitivos o Vainas, solo copiar está bien, no hay necesidad de almacenar punteros. Mover la semántica hace que sea fácil, incluso para los no-PODs, a menos que tenga algo difícil de la construcción o el objeto no puede implementar mover la semántica.

    #include <functional> para std::reference_wrapper y #include <memory> para std::shared_ptr, std::unique_ptr y amigos. Voy a asumir que usted tiene acceso a un moderno compilador.

    • En la mayoría de los casos usted quiere un unique_ptr, no shared_ptr.
  2. 2

    La adición de un bucle para usted.

    #include <iostream>
    #include <queue>
    using namespace std;
    
    int main() {
    
    queue<int*> theQueue;
    char c = 'n';
    
    while (c == 'n') {
      cout << "Enter \'n\' to add a new number to queue ( \'q\' to quit):";
      cin >> c;
      if ( c == 'q') {
        break;
      }
      else {
        int num;
        cout << "Enter an integer and press return: ";
        cin >> num;
        theQueue.push(new int(num));
      }
    }
    
    while( !theQueue.empty() ) {
      cout << theQueue.front() << ": " << *theQueue.front() << endl;
          delete theQueue.front();
      theQueue.pop();
    }
    return 0;
    }
  3. 0

    No estoy seguro de entender, tal vez usted quiere hacer eso:

    #include <iostream>
    #include <queue>
    
    using namespace std;
    
    int main(){
        int firstValueToBePushed = 1;
    
        queue<int *> CheckoutLine;
    
        CheckoutLine.push(new int(firstValueToBePushed));
    
        cout << *CheckoutLine.front() << endl;
    
        return 0;
    }
    • … ay eres una fuga de memoria.
    • Sí, lo sé :).
    • Sería posible para solucionar esta pérdida de memoria mediante el uso de un deconstructor?
    • En mi código, usted tiene que crear un puntero que reciben «CheckoutLine.frontal()», y hacer una eliminación en esta puntero después de la cout. El destrutor es llamada cuando se utiliza eliminar en un puntero o automáticamente para la variable estática.
    • No, un destructor no hacerlo en este caso. Usted tiene que asegurarse de eliminar todos los elementos en la cola antes de salir del ámbito de aplicación (en este caso, la función principal).
    • Hice una prueba con una clase personalizada con un destructor en lugar de tipo int. Y cuando me llamó pop automáticamente llama al destructor que no me esperaba eso. Me dura pop sería sólo elimina el puntero a la clase personalizada y tuve que borrar el puntero antes de llamar pop. ¿Alguien puede confirmar mi conclusión?

  4. 0
    #include <iostream>
    #include <queue>
    using namespace std;
    
    
    int main()
    {
    int  value = 1337;
    
    int* firstValeToBePushed = &value;
    
    
    queue<int*> CheckoutLine;
    
    
    
    CheckoutLine.push(firstValeToBePushed);
    
    
    cout << *(CheckoutLine.front()) << "is at " << CheckoutLine.front();
    
    return 0;
    
    }
    • Sé que esto es sólo para fines de ilustración, pero almacenar punteros a basada en la pila de objetos en un contenedor es siempre sospechoso.
    • Sin duda mejor que el almacenamiento de crudo punteros a montón basado en objetos. Ambos son equivalentes, mientras que el puntero no se le confiere la propiedad.
    • sí, pero es mostrar cómo usarlo. shure puede reemplazar int* firstValToBePushed = &value; con int* firstValToBePushed = malloc(sizeof(int)); *firstValToBePushed = 1337; pero, ¿por qué complicar esto para ilustración
    • no tiene lugar en C++ (y el código no compilador sin un elenco).
    • por qué? «En el peor», raw punteros montón de objetos basados va a dar lugar a fugas. Punteros de pila puede conducir a daños en la pila, que es, de la OMI, por lo general más difícil de depurar (y muy Heisenbug-prono).
    • Rudolph sí de couse im escribir mucho código en c ^^ en c++ uso int* firstValToBePushed = new int; y también un delete al final para evitar fugas de memoria
    • No sé. Ambos son fáciles de atrapar con las herramientas adecuadas. Yo estaba preocupado con la válido el uso de tales indicadores, y un no-ser dueño de puntero (ya sea del montón o pila basada en la memoria) está totalmente bien. ¿Qué no es una multa raw puntero que posee la memoria. Si veo que en el moderno código de C++, yo inmediatamente lo considero un error.

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea