Se registran datos de produccion de puros hasta que el usuario //ingreso "0" como cantidad producida. //El programa debe //-Calcular el promedio de produccion ingresada. //-Determinar la mayor y menor cantidad registrada. //-Mostrar cuantos registros fueron validos antes de finalizar utilizando using namespace std

Aquí te muestro un ejemplo de cómo podrías implementar esto en C++:

```cpp
#include <iostream>
#include <limits>

// Estructura para almacenar cada registro de producción
struct Registro {
    int cantidad;
};

int main() {
    int registros = 0;
    int totalProducido = 0;
    int cantidadMinima = numeric_limits<int>::max();
    int cantidadMaxima = numeric_limits<int>::min();
    bool primerRegistro = true;
    Registro registrosTotales[100];

    while (true) {
        int cantidadProducido;
        std::cout << "Ingrese la cantidad producida (-1 para salir o 0 para calcular estadísticas): ";
        std::cin >> cantidadProducido;

        if (cantidadProducido == 0 && primerRegistro) {
            // Si es el primer registro, calcula estadísticas y termina
            if (registros > 0) {
                std::cout << "Promedio de producción: " << (double) totalProducido / registros << std::endl;
                std::cout << "Registro máximo: " << cantidadMaxima << std::endl;
                std::cout << "Registro mínimo: " << cantidadMinima << std::endl;
                std::cout << "Numero de registros válidos antes de finalizar: " << registros << std::endl;
            }
            break;
        } else if (cantidadProducido == -1) {
            // Si es -1, calcula estadísticas y termina
            if (registros > 0) {
                std::cout << "Promedio de producción: " << (double) totalProducido / registros << std::endl;
                std::cout << "Registro máximo: " << cantidadMaxima << std::endl;
                std::cout << "Registro mínimo: " << cantidadMinima << std::endl;
                std::cout << "Numero de registros válidos antes de finalizar: " << registros << std::endl;
            }
            break;
        } else if (cantidadProducido == 0) {
            // Si la cantidad producida es 0, calcula estadísticas solo si hay registros
            if (registros > 0) {
                std::cout << "Promedio de producción: " << (double) totalProducido / registros << std::endl;
                std::cout << "Registro máximo: " << cantidadMaxima << std::endl;
                std::cout << "Registro mínimo: " << cantidadMinima << std::endl;
                std::cout << "Numero de registros válidos antes de finalizar: " << registros << std::endl;
            }
            break;
        } else {
            // Almacenar registro
            if (primerRegistro) {
                cantidadMaxima = cantidadProducido;
                cantidadMinima = cantidadProducido;
                primerRegistro = false;
            } else {
                cantidadMaxima = std::max(cantidadMaxima, cantidadProducido);
                cantidadMinima = std::min(cantidadMinima, cantidadProducido);
            }

            // Agregar registro a la estructura
            for (int i = 0; i < registros; i++) {
                registrosTotales[i].cantidad = registrosTotales[i + 1].cantidad;
            }
            registrosTotales[registros].cantidad = cantidadProducido;

            // Incrementar registros totales
            registros++;

            // Incrementar producción total
            totalProducido += cantidadProducido;
        }
    }

    return 0;
}
```

Este programa utiliza una estructura `Registro` para almacenar cada registro de producción. El programa tiene un bucle infinito que solicita la cantidad producida hasta que el usuario ingresa 0 o -1, en el cual se calculan las estadísticas. Cada registro se almacena en una estructura y, posteriormente, se calcula el promedio de producción y se determinan la mayor y menor cantidad registrada.