Mensajes

aha... veo que son caprichos del comitee 

Lo que acabas de decir sobre int (como un constante por defecto) me hace bastante sentido quizá por eso la exclusión..

Bueno, y que opinas de lo que pienso sobre las funciones que retornan un tipo que tiene constexpr ?..

Gracias.

No se si me ha quedado mas o menos claro pero lo que acabo de captar es lo siguiente:

1) Las funciones declaradas como constexpr solo van a retornar literales constantes, ej:

Código (cpp) [Seleccionar] Expandir


     return (a + b);
     return 5 * 8;
     return (580 * a + (b / 2));



y nunca variables:

Código (cpp) [Seleccionar] Expandir


     int v = (a + b);
     return v; 

     float x = (580 * a + (b / 2));
     return x;


           

Vi otra cosa respecto a constexpr respecto a int vs double y float..

Código (cpp) [Seleccionar] Expandir



//esto no da problemas:
const int ix = 7;
constexpr double dx = 520.5 * ix;

//pero esto si los da:
const float fx = 7;
constexpr double dx = 520.5 * fx;

//esto tambien da problemas:
const double dx1 = 7;
constexpr double dx2 = 520.5 * dx1;



El compilador dice que ni const float fx, ni const double dx1 son utilizables como constexpr.  en cambio estoy forzado a lo siguiente para que funcione:

Código (cpp) [Seleccionar] Expandir



constexpr float fx = 7.5f;                 
constexpr double dx = 520.5 * fx;



Es decir, en los casos de los tipos double y float, no debo usar const, sino constexpr..

La gran pregunta, por que ?

Salud! y gracias.



 

  No se quien fue el responsable que me dio el dato del libro 


De lo que he visto hasta ahora también se usa con las plantillas...
vamos a ver que tal la sección donde lo aclara con mas detalles...
y por cierto, gracias por la explicacion.

Hola!

"spam"
Por sugerencia de un usuario del foro me he comprado el libro "The C++ Programming Language 4th Edition - Bjarne Strouptup",
"/spam"  (perdón  ) entonoces he llegado a una parte que empieza a hablar sobre constexpr,  pero aun no entiendo bien su funcionamiento, es decir, es lógico que quiere decir que se pueden crear expresiones constantes, pero no le veo mayor diferencia con la palabra reservada const al menos por ahora....

Lo que llegue a comprender solamente es que no puedo asignarle valores no-constantes a una expresión constante.....  estoy seguro que es constexpr es algo muy muy útil...  alguna luz del para que sirve?

Gracias..

Ok, entonces la función rellenarTabla() en realidad no estaría bien verdad?, tendría que desglosarla.... ya que estaría mezclando dos capas en una sola función..

podría desglosarla así?:

Vista:

Código (cpp) [Seleccionar] Expandir



//Incluyo la cabecera que manipula el controlador
#include "Manager.h"

//suponiendo que tengo una variable que represente a la tabla y se llame
//tbl_data
void UMasterWindow::mostrarTabla(){
     Controller::Manager manager;

     ui->tbl_data = manager.controlarTabla(tbl_data, "Usuarios");
     ui->tbl_data->show();
}




Controlador:

Código (cpp) [Seleccionar] Expandir


//Incluyo la cabecera que manipula la visual de la tabla...
#include "QTableView.h"
#include "SQLManagement.h"
#include "UMasterWindow.h"

QTableView Manager::controlarTabla(QTableView tbl_data, QString tbl_name){
     Model::SQLManagement sqlM;

     QString queryCmd;
     queryCmd = "SELECT * from " + tbl_name;
     return sqlM.rellenarTabla(tbl_data, queryCmd);
   
}


//Modelo:

Código (cpp) [Seleccionar] Expandir


#include "Manager.h"
#include "QTableView.h"

QSqlQueryModel * model = nullptr;

QTableView SQLManagement::rellenarTabla(QTableView tbl_data, QString queryCmd){
     model = new QSqlQueryModel;
     QSqlQuery query;
     query.exec(queryCmd);
   
     model->setQuery(queryCmd);
     tbl_data->setModel(model);
     cerrarBD();

     return tbl_data;

}

void SQLManagement::cerrarBD(){
     delete db;
     db = nullptr;
}



Es asi como lo imagino, no se si estará bien... 
Me recomiendan un buen curso de MVC?.. necesito ver en la practica con el código como funciona, porque el ejemplo que acabo de poner me parece una espagueti...

Saludos y gracias!

Gracias por las respuestas..

me queda claro todo, lo único si que no comprendí bien el por qué de dos cosas

por qué dices que no debo usar system("cls"); de que otra forma puedo limpiar pantalla?..  (conozco otro método que es insertar 100 lineas vacías pero esto haría que el contenido se muestre abajo)

y lo otro, es el std::endl;  la otra forma que conozco es con la secuencia de escape \n

Saludos!

Entiendo, gracias por las explicaciones...

Por ejemplo, hoy mismo me he encontrado con un caso particular, el rellenado de una tabla con datos de la base de datos..

la tabla es pertenece a una interfaz gráfica (V)
los datos se extraen de una ejecución de SQL.. (M)

Tengo la siguiente función:

Código (cpp) [Seleccionar] Expandir


int UnaClase::rellenarTabla() {

     //Conectar con base de datos
     //ejecutar consulta SQL
     //obtener datos y meterlos a la tabla (V)

}


Como verán, aqui se mezcla los datos con la visual...
En que namespace o capa debe quedar esta función?

O quizá esté mal empleada la función...
Que tipo de datos se comparten entre capas?.. solo primitivos?, mi duda es esta ya que no me parece muy lógico dividir en capas y compartir tipos específicos de cada capa una con otra..

Disculpen tantas preguntas..

Gracias, saludos!11

Rayos cósmicos... he intentado sobrecargar al menos el operador < .. pero algo no anda bien..  esta vez compila, pero no se comporta como esperaba

Código (cpp) [Seleccionar] Expandir



#include "pch.h"
#include <iostream>
#include <set>

class Usuario {

char * nombre = nullptr;


public:
Usuario() : nombre(new char[16]) {}
~Usuario();

void SetNombre(const char * _nombre);


char * GetNombre() const {
return this->nombre;
}

friend bool operator<(const Usuario & _thisUser, const Usuario & _otherUser);


};

Usuario::~Usuario() {
delete[] nombre;
}

void Usuario::SetNombre(const char * _nombre) {
strcpy(this->nombre, _nombre);
}

bool operator<(const Usuario & _thisUser, const Usuario & _otherUser) {

for (int l = 0; l < 16; l++) {
if (_thisUser.nombre[l] < _otherUser.nombre[l]) {
return true;
}
else {

if (_thisUser.nombre[l] == _otherUser.nombre[l])
continue;

else
return false;

}
}


}



std::set<Usuario> usuarios;

int main(){

char * _nombre = new char[16];

for (int x = 0; x <= 3; x++) {

system("cls");

std::cout << "Ingrese nombre: ";
std::cin >> _nombre;

std::cout << std::endl;

Usuario usuario;
usuario.SetNombre(_nombre);

usuarios.insert(usuario);   //ciclo 0 lo realiza bien
                                                      //al intentar guardar en el ciclo 1 se congela

}

delete[] _nombre;
_nombre = nullptr;

return 0;

}


He optado por set<> porque deseo ingresar usuarios y no deben repetirse...
Estoy casi seguro que no he sobrecargado correctamente el operador..

Gracias por las respuestas...

Muy bien, creo que tomare todas las opciones, tanto para comparar como para imprimir la clase y determinar el orden...

< , << y ==

Y gracias también por los enlaces..

Hola amigos..

Estoy experimentando con el contenedor set y tengo duda con el operador de sobrecarga que se necesita para meter al contenedor un tipo creado por mi mismo...

Según estuve leyendo y alguien me dijo también que necesito sobrecargar el operador <

Pero este operador menor que, en que forma hace la comparación de elementos?, el contenedor set no permite objetos duplicados, no seria mas lógico sobrecargar == en vez de < para comparar si el elemento ya existe?