Hola amigos..

Tengo que diseñar un programa que será un cliente hecho en Qt C++, se debe conectar a una base de datos alojada en un servidor.

La situacion es que son 13 regiones, cada region tiene 15 modulos, y cada modulo utiliza 7 tablas independientes, entonces como verana son muchas muchas tablas (ese es mi concepto, posiblemente este equivocado), cada modulo ingresa informacion separada del resto, por eso pienso que son cientos de tablas...

Que se hace en este caso?

1) Crear una sola base de datos gigante que tenga 1365 tablas (13 x 15 x 7) y distinguirlas con un prefijo, ejemplo:  table_region0_modulo0_usuarios, table_region0_modulo0_direcciones, etc

2) Crear 13 bases de datos y 105 tablas por cada db..

3) Otra ...

All final, la idea es que cada modulo ejecute su cliente del programa, y se conecte al indice de su propio modulo y lea la informacion segun ese sufijo...


Como les he comentado, los registros de usuarios del modulo 0 no son los mismos que los del modulo 1.. por eso pense en crear muchas tablas..

Que hacer en este caso?
saludos y gracias.

Hola!

Hago esta pregunta desde la ignorancia, entiendo que virtual/override ayuda mucho a no tener que redefinir trozos de codigo de una función, sin embargo no entiendo cual es el fin de las funciones virtuales puras, es decir, no implementan nada, solo veo que ocupan un espacio en el archivo de cabecera, al fin y al cabo de todas formas tendrás que volver a declararlas y definirlas en las subclases como override...



Por qué no directamente?:

Buenas noches:

De la misma forma que se puede virtualizar una función y sobreemontarla en alguna clase hija... me pregunto si es posible hacer lo mismo con los enums....

por ejemplo:





Como verán, cada clase tiene sus propios elementos enum, sin embargo, para que la función una_funcion(mis_objetos) pueda sobremontarse, es necesario que el enum exista en el padre..

Es posible hacer esto? (con el codigo estoy especulando, lo mas seguro que tenga errores)

Gracias.

Muy buenas..

Tengo un mal concepto quizá de lo que son las variables estáticas, yo las imagino algo asi como un contenedor que se crea automáticamente al iniciarse un programa, vive durante todo el programa y luego se cierra una vez que el programa termina... como un bolso de viaje que tomas al iniciar el viaje y te deshaces de él cuando regresas a casa... asi es como yo las veo.. (por favor, indicarme si estoy mal).

El siguiente código no esta reflejando esto:

main.cpp

#include <iostream>
#include "Archivo2.h"
#include "Archivo1.h"
 
int main() {
	x::num = 10;
	std::cout << "Desde main -> " << x::num << "Memoria : " << &x::num;
	std::cout << std::endl;
	Archivo1 a;
	a.printVal();
	return 0;
}
 

Archivo1.h

#pragma once
struct Archivo1{
	void printVal() const;
};
 

Archivo1.cpp

#include "Archivo2.h"
#include "Archivo1.h"
#include <iostream>
 
void Archivo1::printVal() const {
	std::cout << "Desde Archivo1 -> " << x::num << "Memoria : " << &x::num;
 
}
 

Archivo2.h

namespace x{
     static int num;
}
 

La salida de consola "Desde Main ->" imprime 10
La salida de consola "Desde Archivo1 ->" imprime 0...

Creí que estaba imprimiendo el mismo elemento, pero no, cuando le agregue que imprimiera la dirección de memoria, me encontré con la sorpresa de que ambas estan imprimiendo direcciones diferentes....

En qué momento se creó una nueva instancia de la variable estática y como puedo solucionar este dilema?.. mi intención es escribir e imprimir en una sola variable x::num

Saludos_!

Buenas..

Tengo este código y me está saliendo error, ppienso que la sintaxis está correcta.. aun no entiendo por qué el error..  Alguna pista?


Ver en el siguiente enlace el codigo para probar:
https://onlinegdb.com/ryO2ptQ7B

Saludos.


Edit : Le quite el simbolo de referencia en el parámetro para la funcion de la linea 5 y ahí compiló..
Pero no veo por qué...

Hola amigos.. que tal.

Tengo una gran duda, la verdad me confunde un poco el hecho de que se pueda inicializar una variable de 3 formas:

int x = 3;
int y {4};
int z(5);
 

Las 3 son válidas, bueno, así como se ve, no está complejo realmente, el problema es cuando usas elementos como un contenedor.. ya que los contenedores aceptan una lista de argumentos encerradas en llave, sin embargo esto me confunde un poco, porque no se cuando está inicializando o cuando está pasando por argumento a un constructor.. o cuando está usando un constructor de conversión.. etc..


Ejemplo:

 
vector<string> vs { "Hola", " Que tal"};     //No hay problema..
vector<string> vs2 { 5, 1 };                     //Houston
 
istream_iterator<string> is;
istream_iterator<string> is2;
 
vector<string> vs3{is, is2};                     //No hay problema.. por que?
 
 

Sospecho que en vs3 no estoy inicializando … pensé que las llaves eran para eso... que esta pasando en esta línea?..


Saludos y gracias.


--------------------------------

Edito:

Estuve viendo los constructores que tiene std::vector y encontre uno que acepta un iterator de inicio y otro de fin... entonces eso es lo que debe estar aceptando, es decir,  vs3 no esta inicializando, solo le estoy pasando los iteradores que están conectados al flujo de entrada ifstream....  En el fondo lo que me habia confundido es el uso de las llaves, tenia entendido que las llaves servian para inicializar en los contenedores, pero ya vi que hace lo mismo que los parentesis, a menos que este poblando al contenedor, ahi seria una inicialización...

Saludos.

Hola amigos..

En el siguiente código, si yo quito la palabra const (línea 52) derivada de un template tipo C, el programa corre....


Link -> https://onlinegdb.com/SyW1F9kWS
Hagan clic en Fork para probar el código.

Estuve buscando por què pasa esto, segun el compilador no pudo realizar una conversion de un tipo que no es const a uno que es const...  entiendo que quitando la palabra const se acaba el problema, pero por que?.. y si no deseo retirar la palabra const donde mas debería agregarla para que pueda compilar?... (Pasa que el libro que estudio aparece con const, ero no veo diferencia realmente con lo que tengo).

Gracias.

---

Bueno, según un usuario de discord, me dijo que las funciones begin() y end() deben ser const también, y efectivamente colocándolas asi compiló correctamente.

Pero es curioso porque en el libro que estudio, dichas funciones no son const..

Ahora mismo estoy investigando por que´.

---

Si yo coloco las funciones begin() y end() como funciones no miembro, es decir, fuera de la clase o estructura, el compilador no las detecta...

Lnik -> https://onlinegdb.com/SJgL5ayZH


Debe forzosamente ser funciones miembro?

EI: NO HAGAS DOBLE POST NUEVAMENTE, SERA BORRADO.

Hola amigos. que tal.

Tengo el siguiente caso:

 
#include <iostream>
#include <initializer_list>
 
struct x {
private:
     int * iArray = nullptr;
     int tam;       //Sin inicializar
 
public:
     x(std::initializer_list<int> lst) : iArray{new int[lst.size()}, tam{lst.size()}{
          std::copy(lst.begin(), lst.end(), iArray);
     }
 
     //Constructor de copia
     x(const x & otherX);
 
};
 
//Definición de constructor de copia (notar aquí que al momento de hacer
//la primera inicialización tam no ha recibido valor.
x::x(const x & otherX) : iArray{new int[tam]}, tam{otherX.tam}{
     for (int y = 0; y < tam; ++y){
          iArray[y] = otherX.iArray[y];
     }
}
 
int main (){
     x x0 {2, 4, 6};
     x x1 = x0;   //copia correcta...
 
     //prueba directa de asignacion de una variable no definida a un array dinamico:
 
     int x;
     int * arr = new int[x];     //error, x no está definida.
}
 

Como se puede observar, en la linea 22 se está inicializando el array dinamico con un tamaño de tam antes que inicializar al mismo tam, o sea, se esta inicializando con un valor desconocido...  sin embargo, esta funcionando bien, ahora bien, en la linea 35, se esta intentando crear un array dinamico con un tamaño x, pero no sirvio.... acaso la inicialización funciona distinto a la asignacion?

Gracias, saludos.

Buenas..

Me ha causado extrañeza la forma en que se puede inicializar un tipo a traves de un argumento al constructor:

struct s {
private:
	int x = 0;
public:
	s(int _x) : x{ _x } {}
	void p() const { std::cout << x; }
	int getx() const { return x; }
};
 
int main() {
	s _s(5);                                       //forma argumento a constructor 1
	s _t = 6;                                     //forma argumento a constructor 2
	s _u{ 7 };                                   //forma argumento a constructor 3
	s _v = { 8 };                              //forma argumento a constructor 4
 
	std::cout << std::endl;
	std::cout << _s.getx() << std::endl;		//salida : 5
	std::cout << _t.getx() << std::endl;		//salida : 6
	std::cout << _u.getx() << std::endl;		//salida : 7
	std::cout << _v.getx() << std::endl;		//salida : 8
	return 0;
}
 

Siempre he inicializado un tipo (que reciba un argumento de constructor) con los parentesis, es decir, tal como sale en la salida 5, es decir:

s _s(5);
 

Sin embargo, estaba convencido que la siguiente linea solo tenia como fin la asignacion de un valor:

s _t = 6;
 

Me ha parecido curioso porque se supone que una asignacion por regla general debe tener el mismo tipo que el asignado... sin embargo, el tipo s no es un entero.


Entonces me pregunto si esa linea realmente es una asignacion o lleva otro nombre....

Hola nuevamente:

El siguiente código:

#include <iostream>
 
using namespace std;
 
struct s{
 
private:
    double * d = nullptr;       
 
public:
    s() : d{new double}{}
    ~s(){ if (d != nullptr) delete d; }
    void setd(const double _d){ *this->d = _d; }
    double getd() const { return *this->d; }
 
};
 
s operator+(const s & _s0, const s & _s1){
    s ns;
    ns.setd(_s0.getd() + _s1.getd());
    return ns;
}
 
int main(){
 
    s s0;
    s s1;
 
    s s2;
    s2 = s0 + s1;
 
    return 0;
}
 
 

Aqui listo para ejecutar:
https://onlinegdb.com/rJNPQ68kr

Al ejecutar, obtengo el mensaje de error:

*** Error in `./a.out': double free or corruption (fasttop): 0x0000000000795c80 ***                                             
Aborted (core dumped)

Estoy seguro que el problema esta entre el puntero privado y el delete en el destructor, ya que si no uso puntero, compila bien.

Sin embargo, he puesto puntero porque quiero entender qué está pasando.  Me da la impresión de que en la definición del operador+ como se crea el objeto ns al terminar el ámbito, se está destruyendo y esta eliminando el puntero.  Lo cual parece valido, pero no tendría por qué corromper la ejecución, se supone que estoy destruyendo un objeto de copia, no los operandos utilizados.