En el array, pones los parámetros para construir los objetos entre llaves:

string strs[] = {{"a", 1}, {"b", 1}, {"c", 1}};

Lo que comentas no es posible.
De todos modos, en C++11 es preferible utilizar clases como vector en vez de arrays de C.

Claro que puedes crear un array de punteros. Y la linea que muestras esta bien, deberia compilar sin problema. Muestra el error que te da el compilador.

Esto es raro. Si intento compilar el ejemplo del string:

std::string cadenas[100] = {"Cadena"};

si que funciona, pero si lo hago para un tipo de dato definido por mi:

#include <iostream>
 
class Objeto {
public:
    Objeto(int n);
};
 
int main() {
    Objeto cadenas[100] = {1};
 
    return 0;
}

si que me da error:

Bueno, tras realizar algunas comprobaciones tecleando código, he llegado a las siguientes conclusiones:

Lo que hace C++11 es decir: vale, te permito crear un arreglo e inicializarlo con una initializer_list con un número de elementos menor o igual al tamaño del arreglo, pero bajo las siguientes condiciones:

• Si el número de elementos del initializer_list es igual al número de elementos del vector, entonces puedes crearlo sin problemas
• Si el número de elementos del initializer_list es menor que el número de elementos del vector, te dejo crearlo, pero tienes que definir un constructor que acepte un initializer_list (con cualquier tipo base). Entonces, lo que el compilador hace es lo siguiente (hablo de mi compilador, no sé si será estándar): Tomo los primeros elementos del initializer_list y con ellos construyo los primeros elementos del vector. Con los últimos elementos del vector, llamo al constructor con un initializer_list vacío(si hubiera varios con varios tipos, entonces marcaría error de ambigüedad). Posteriormente pongo un ejemplo
• Si el número de elementos del initializer_list supera el número de elementos del vector, se marca error

Ejemplo de la segunda condición:

#include <iostream>
#include <initializer_list>
 
class Objeto {
private:
    int u;
 
public:
    Objeto(int n);
    Objeto(const std::initializer_list<char> &n);
 
    void Imprimir();
};
 
int main() {
    Objeto cadenas[3] = {1, 1};
 
    std::cout << std::endl;
 
    for(int i = 0; i < 3; i++)
        cadenas[i].Imprimir();
 
    return 0;
}
 
Objeto::Objeto(int n) {
    std::cout << n << std::endl;
 
    u = 1;
}
 
Objeto::Objeto(const std::initializer_list<char> &n) {
    std::initializer_list<char>::iterator it;
 
    std::cout << "Initializer (size = " << n.size() << "): ";
    for(it = n.begin(); it != n.end(); it++)
        std::cout << *it << ' ';
    std::cout << std::endl;
 
    u = 2;
}
 
void Objeto::Imprimir() {
    std::cout << u << std::endl;
}

La salida del siguiente código:


Como podéis ver, para los primeros elementos, se llama al constructor de parámetro tipo 'int' (aquí pongo un poco de conversión implícita), y cuando se queda sin elementos, se llama al constructor con el initializer_list con cero valores. Si hubieramos definido otro constructor con initializer_list con tipo, por ejemplo, std::string, hubiera dado error de ambigüedad.

Espero haberme explicado bien. Esta es una particularidad de C++ que desconocía por completo