Mensajes

[MOD: Movido el código dentro de la etiqueta GeSHi]

buenas

Al imprimir en el terminal el nombre del tipo de unas variable me imprime solo la primera letra.

Código (cpp) [Seleccionar] Expandir


int m = 6;
std::cout << typeid(m).name();

Imprime: i
Es eso debido al compilador? Estoy usando Linux

Saludos

MOD: Movido el código dentro de la etiqueta GeSHi

Buenas señores..

Tengo una duda a medias... creo entender como va esto de las plantillas pero quisiera estar seguro.

Del siguiente codigo:

Código (cpp) [Seleccionar] Expandir

template <typename T>
void my_function ( T _param);


Entiendo que para este caso, T es un tipo generico que acepta cualquier clase de argumento (puntero, referencia o valor)
Como quien dice, no tiene formato, puede ser constante, estatico, etc...

Código (cpp) [Seleccionar] Expandir

int x = 19;
my_function ( x );  //en la plantilla, T se transformaria en int    ....     int _param = 19;

int * px = &x;
my_function ( px );  //en la plantilla, T se transformaria en int *    ....      int * _param = &x;

Como T es virgen (por decirlo de alguna forma), no esta pre-formateada, simplemente es una T sola, puede aceptar cualquier tipo de clase y con cualquier tipo de atributo... es asi?



Pero en este siguiente caso:

Código (cpp) [Seleccionar] Expandir

template <typename T>
void my_function ( T* _param);


Aqui T es puntero, entiendo que solo acepta una direccion de memoria u otro puntero, pero no un elemento por valor, ya que T* ha sido pre-formateado para funcionar solo como puntero.

Código (cpp) [Seleccionar] Expandir

int x = 19;
my_function ( x );  //esto produce un error porque x es un tipo, no un puntero....

int * px = &x;
my_function ( px );   //esto estaria bien, ya que seria una asignacion de puntero....


Segun entiendo, en el fondo la asignacion a un tipo plantilla es como si se comportara como override de funcion:


T = Acepta cualquier cosa por valor
T& = Acepta cualquier cosa solo que como referencia
T* = Preformateada para aceptar solo punteros o direcciones de memoria o referencias a punteros
const T = Preformateada para aceptar cualquier cosa por valor pero se transforma obligatoriamente en constante
const T& = Preformateada para aceptar cualquier cosa por referencia pero se transforma en constante
const T* = Preformateada para aceptar solo punteros o direcciones de memoria y lo transforma a constante.


En el siguiente ejemplo:

Código (cpp) [Seleccionar] Expandir

template <typename T>
void my_function ( const T* _param);

const float * pfloat = new float(12.5f);
my_function ( pfloat );   //esto se asignara bien.

float * pfloat2 = new  float (6.9f);
my_function ( pfloat2 );   //esto tendria el mismo efecto que pfloat ya que en la plantilla siempre quedara como const.




Es mas o menos como lo creo?

Saludos

Buenas estimados.

Estoy estudiando un libro de SFML, y en una de sus paginas al usar plantillas para cargar recursos menciona que cuando se trabaja con plantilla de clases es bueno renombrar la cabecera a .hpp y las definiciones de los metodos en .inl .. incluyendo dicho .inl al final del .hpp

El libro no explica claramente el por qué.
Se debe esto a alguna convencion o tiene un significado objetivo?


saludos y gracias.

Hola amigos...

Estoy desarrollando un programa, y se esta volviendo un poco spaghetti, es un sistema de e-learning:

Tengo el siguiente escenario (para resumirlo):

Código [Seleccionar] Expandir


class A{

    B objetoB;
    std::vector<C> objetosC;
   
};

class B{

    X objetoX;
    std::vector<Y> objetosY;


};

class  C { ...}
class X {...}

class Y {

    std::string palabra = "Hola";
}


//singleton.h
std::vector<A> todos_los_objetos_A;
std::vector<B> todos_los_objetos_B;




En mi caso son mas clases pero expuse esto para aislar mi duda...
encontrar un subobjeto Y y acceder a la variable "palabra" desde fuera se esta volviendo tremendamente tedioso... .. tan solo para modificar la palabra "Hola" a "Hello" (por ejemplo).. debo escribir lo siguiente:

Código [Seleccionar] Expandir


singleton s;
s.todos_los_objetosA[0].objetoB.objetosY[2].palabra = "Hello";


Imaginar que el vector tiene 20 elementos al menos y que el total de clases son 10... y por si fuera poco, cada indice de vector debo calcularlo previamente tambien, luego una vez encontrado, debo excavar demasiado para modificar el bisnieto de una clase...  no se si hay alguna solucion para evitar esto, ya que es propenso a confusión y errores....  estuve pensando en deshacer las composiciones y dejar todos los vectores en singleton.h

Código [Seleccionar] Expandir


//singleton.h
std::vector<A> todos_los_objetos_A;
std::vector<B> todos_los_objetos_B;
std::vector<C> todos_los_objetos_C;
std::vector<Y> todos_los_objetos_Y;


.. y acceder a los objetos de los subindices directamente en la raiz de la clase singleton...  esto rompe un poco el paradigma orientado a objetos pero me da la impresion de que es menos confusion...


Que harian en mi caso?  estoy usando base de datos.


Saludos.

Buenas..

Tengo una red de mas de 30 computadores y 3 proveedores de internet, un proveedor entrega 500mpbs, otro 200  y un tercero 60..

Mi intencion es que el balanceador utilice solamente la primera red (500) para que los equipos puedan navegar mas rapido, en caso de que ese proveedor se caiga o tenga problemas, solo ahi pasar al siguiente (200) y asi con el siguiente...

Es posible configurar un balanceador de esa forma?
O quiza haya alguna forma de distribuir los 3 proveedores paralelalmente por toda la red?.

O como recomiendan ustedes para este caso ?

saludos y gracias

Perfecto, gracias.

Hola.. espero que se encuentren bien.

Me ha asaltado una duda con las clases, sus miembros y punteros...  Suponiendo el siguiente ejemplo:

Código [Seleccionar] Expandir


class Alpha{
private:
    ObjetoA  objA;
    ObjetoB  objB;
};


void main(){
    Alpha* a = new Alpha;
}


Desde main, un objeto de tipo Alpha se está almacenando en la memoria dinamica....
Pero el objeto Alpha tiene otros dos objetos que no son punteros, tambien se estan almacenando en la memoria dinamica?.... o estos dos se separan (fisicamente) de la clase y se almacenan en la pila?..

Saludos..

perfect!!!... muchas gracias

Entiendo, gracias..

La idea mia es que se ejecute en cadena.. como un ensamble, es decir, la linea

Código (cpp) [Seleccionar] Expandir


_y.do_xy();


deberia ejecutar:
from x
from y

por esta razon utilice el keyword "override"...

Hola amigos..
Que pasa en este codigo que la funcion virtual do_xy() en x no se está ejecutando?

Código (cpp) [Seleccionar] Expandir


#include <iostream>

struct x{ 
  x(){}
  ~x(){}
 
protected:
  virtual void do_xy(){
      cout << "from x " << endl;     //esto no se ejecuta
  } 
};

struct y : public x{
  y(){}
  ~y(){}
 
public:
  void do_xy() override{
      cout << "from y " << endl;     //esto se ejecuta
  }   
};

int main(){
    y _y;
    _y.do_xy();
   
    cin.get();
    return 0;
}


Saludos.. gracias.