una - matriz c++ ejemplos

El cuerpo de inicialización de la matriz como parámetro de función(matriz C), ¿es posible?

Question

Estoy buscando ayuda en la siguiente situación:
Tengo algunas clases y algunos métodos, la sintaxis es así:

class SomeClass {  
    public:  
            void doSomething(int *a);  
};

Así que quiero llamar a este método como

SomeClass::doSomething({ 0, 1, 2, 3, 4 });

¿Es posible en cualquier idioma? ¡Cualquier implementación (C ++, C, obj-c, obj-c ++) es bienvenida! Sé que este bloque de inicialización es un cuerpo de matriz, como

int *a = { 0, 1, 2, 3, 4 };
SomeClass::doSomething(a);

Pero la interfaz se verá muy bien, creo, si no habrá variables temporales antes de las llamadas a funciones (ya que no necesitamos saber el tipo de parámetro en la clase-cliente). Entonces, ¿hay alguna posibilidad de hacer esto?

Answer 1

En C99 esto funciona:

functionThatTakesIntPtrOrArray( (int []){ 1, 2, 3, 4 } );

..y cosas similares se pueden hacer con estructuras.

Answer 2

Esto es sobre las listas de inicialización de C ++ 11 (sección 18.9 ).

void foo (std :: initializer_list <int> inputs) {
    for (auto i : inputs) {
        // ...
    }
}

foo ({10, 20, 30});

Solo el compilador puede crear una lista de inicialización, pero puede tratarlo como un contenedor estándar de estilo STL con iteradores de begin() , end() , size() e acceso aleatorio.

std::vector (y espero que algunos otros contenedores) ahora se puedan construir con listas de inicializadores, por lo que

std :: vector <std :: string> foo {"a", "b"};

es equivalente a

std :: vector <std :: string> foo;
foo .push_back ("a");
foo .push_back ("b");

excepto que puede realizar menos asignaciones. Tenga en cuenta que los caracteres const char* se han convertido en std::string automágicamente.

Answer 3

Si initializer_list no está disponible, y las matrices son en su mayoría pequeñas, hay otra opción, sobrecargar << operador para std :: vector como este:

template <typename T>
inline std::vector<T> operator <<( const std::vector<T>& vec, const T& val ) {
    std::vector<T> result(vec);
    result.push_back(val);
    return result;
}

Con eso, puedes hacer esto:

void foo (const std::vector<int>& inputs) {
    // ...
}

foo ( std::vector<int>() << 10 << 20 << 30 );

Hay un precio que pagar por esta conveniencia de inicialización de una sola línea y no tener que especificar el tamaño del vector. Se crea una copia del vector anterior para cada elemento que se agrega, lo que hace que el tiempo de ejecución sea al menos cuadrático en el tamaño del vector. Por eso es más adecuado para vectores cortos y casos en los que el rendimiento no importa. Hay una mejor solución para C ++ 11, como se señala en la respuesta de Spraff.