C++ crea de forma implicita un contructor por defecto (sin parametros) y sobrecarga el operando de asignacion en el caso de que la clase sea bastante trivial, es decir implementa lo siguiente a partir de tu codigo:

class s {
private:
	int x;
public:
	s() { x = 0}
	s(int x1) { x = x1; }
	s operator=(int x1) { x = x1; return *this; }
	void p() const { std::cout << x; }
	int getx() const { return x; }
};

La linea s t = 6; en el main llama al constructor por defecto s() y pone x = 0, luego llama s.operator=(6) y pone x = 6

Otra cosa que no tiene que ver con tu pregunta, NUNCA pongas uno o dos guion bajo al principio del nombre de una variable en C++, esos nombres estan reservados para las librerias del lenguaje y es una mala practica de programacion que deriva de los lenguajes no case-sensitive como Visual Basic donde para diferenciar User y user escribes _user.

Hay formas de nombrar a la variables que suelen prevalecer, y en algunas librerías, en la documentación prácticamente te fuerzan a su manera.

Es mejor la segunda opción.
Por qué?
Porque alguna librerías suelen usar el guion bajo para separar el tipo del dato del nombre de la variable.

El un_numero se podría interpretar como una variable unsigned int. Mucho lo entederan como UnsignedNumberNumero.

En algunas librerías se nombran de esa manera, por ejemplo p_Numero lo entenderan como un puntero.

Librerías como la windows api usan la inicial para describir el tipo de variable. Por ejemplo nVariable se entiende como una variable que contiene un número. hVentana es un handler a una ventana. Etc.

A mi me gusta usar variables que empiecen en minúsculas con nombres largos que describan mejor lo que almacenan. Para las funciones uso la primera mayúscula. Para defines uso todo mayúsculas.

Asi si lees en mi codigo:
funcion variable
Funcion funcion
FUNCION macro

Sabes que siempre uso el mismo método y puedes saber que es.
En caso de sobrecargar funciones para que devuelvan datos distintos con el mismo nombre uso:
n_Funcion numero
c_Funcion caracter
s_Funcion string
...

No es importante que método uses, lo importante es que no lo cambies durante todo el código y siempre respetes esa norma a rajatabla.

Yo suelo poner nombres largos del estilo:
unsigned short int numeroDeCaracteresQueContieneElArrayescenario;
Podrias usar la abreviatura y añadir un comentario.
unsigned short int n_soae; //Size of Array escenario

Con esta forma de nombrar las variables puedes acordarte facilmente palabras largas que comentaste en la declaración de la variable:
noeiaoslistaDeAdmitidos
number of elements inside array of strings "listaDeAdmitidos".

Desde luego es preferible a llamarle a las variables a, b, c, d...
Imaginate que en la linea 4582 del código declaraste:
int a;
char b;

en la línea 4800 del código:
string c;
Mivector d {4, a};

En la linea 5430 del codigo:
string e = "ejemplo";

En la línea 6323:
string f = e;
//operaciones

if (operacion1 == operacion2)
{
e = f;
}
 
Y en la línea 7214 tienes:
if (a<=b || e.size() <= a && f.size() != 2 )
{
   for (int i = 3; i < e.size() || i != f.size() +a ; ++i)
   {
   i = a;
   ++a;
    e.append(f, a,( e*e.size())-a));
      while (!e.empty())
      {
       for (auto iter ....
       {
         f.append(*iter);
        e.resize((e.size()-1));
        }
       }
    }
}
 

Vas a tener que andar a buscar por el codigo 200 veces paea entender una funcion.
Podrias ahorrar todo ese sufrimiento al lector de codigo con un simple comentario de 2 lineas y usar nombres que representen mejor que tiene cada cosa:
/*
Este codigo llena el vectorNombresDeAlumnos del tipo creado MiVector vector<inicialesDeAlumnos>
Si el string sColegio no ha sido modificado previamente. */

En el caso del código que pusiste, en esta línea:

s _t = 6;
 

en realidad no se invoca al constructor por defecto ni al operator=. De hecho, dando  que tú ya escribiste un constructor, el compilador ya no genera la versión por defecto o sin parámetros (sólo la genera si tú no creas ninguno, o si se lo pides, con  = default). Y por supuesto, en ningún caso generaría una sobrecarga de operator= que tome como parámetro un int. El único operador de asignación que el compilador generará automáticamente toma como parámetro una referencia const (en algunos casos, no const) al mismo tipo de la clase, en este caso s.

Lo que en realidad sucede en esa línea es que se invoca al constructor que tú definiste, y se le pasa como parámetro 6. O sea, es equivalente a esto:

s _t(6);
 

En cuanto a tu última pregunta, en general, el compilador genera un operador de asignación para cualquier tipo que crees, salvo unas pocas excepciones (por ejemplo, si contiene alguna variable miembro no static que sea const, o referencia)

Entiendo, ya me va quedando todo mas claro... gracias por las respuestas..

Vaya Stroustup, que le gusta complicar las cosas, pero supongo que es para mejor...