|
|
Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.
Mensajes - AnioN
Páginas: 1 [2] 3 4 ... 14
26
« en: Jueves 28 de Junio de 2007, 22:28 »
que no tiene parámetros, significa justamente eso, no tiene parámetros.  Estos cdigos son analogos: void casa(void) { .......... }
27
« en: Viernes 22 de Junio de 2007, 00:32 »
y como seria llamarlo en forma fucional a los operadores << y >> ? por ej: class punto { int x,y; public:punto() {x=y=0;} punto (int xx,int yy) { x=xx;y=yy;} void fijarx(int xx) { x=xx;} void fijary(int yy) {y=yy;} int leerx() {return x;} int leery() {return y;} friend ostream& operator << (ostream& os,const punto &p); friend istream& operator >> (istream& is,const punto &p); }; void main() { punto p; cout<<p<<endl; p.fijarx(50); p.fijary(100); cout<<p<<endl; cout <<"introducir los valores de x e y\n"; cin>>p; cout<<"se ha introducido"<<p; } ostream& operator<<(ostream &os,punto &p) { os <<"x= "<<p.x<<",y= "<<p.y; return os; } istream& operator>>(istream &is,punto &p) { is >>p.x>>p.y; return is; }
28
« en: Jueves 21 de Junio de 2007, 16:53 »
en cualquier compilador de borland las tenes por default.
29
« en: Jueves 21 de Junio de 2007, 14:56 »
Hola, estoy buscando un texto que explique bien la sobrecarga de operadores en C++, no me quedan claras algunas cosas todavia referidas. Por ej no se cuando tienen que ser declarados como friend y cuando no. Ademas de la sobrecarga de los flujos de i/o. Lo que me quedo en duda es que lei por ahi que el compilador los interpreta como de funciones se tratase. Alguien me puedo aclarar estas dudas? Por ej este codigo: #include <iostream> using namespace std; struct complejo { float a,b; }; /* Prototipo del operador + para complejos */ complejo operator +(complejo a, complejo b); int main() { complejo x = {10,32}; complejo y = {21,12}; complejo z; /* Uso del operador sobrecargado + con complejos */ z = x + y; cout << z.a << "," << z.b << endl; cin.get(); return 0; } /* Definición del operador + para complejos */ complejo operator +(complejo a, complejo b) { complejo temp = {a.a+b.a, a.b+b.b}; return temp; }
Aclara que puede ser usado en su notacion funcional, de la sig manera: Este otro ejemplo: #include <iostream> using namespace std; class Tiempo { public: Tiempo(int h=0, int m=0) : hora(h), minuto(m) {} void Mostrar(); Tiempo operator+(Tiempo h); private: int hora; int minuto; }; Tiempo Tiempo::operator+(Tiempo h) { Tiempo temp; temp.minuto = minuto + h.minuto; temp.hora = hora + h.hora; if(temp.minuto >= 60) { temp.minuto -= 60; temp.hora++; } return temp; } void Tiempo::Mostrar() { cout << hora << ":" << minuto << endl; } int main() { Tiempo Ahora(12,24), T1(4,45); T1 = Ahora + T1; // (1) T1.Mostrar(); (Ahora + Tiempo(4,45)).Mostrar(); // (2) cin.get(); return 0; }
Que pasa si yo declaro al operador como friend?
31
« en: Miércoles 20 de Junio de 2007, 01:56 »
por que no es posible la herencia multiple en la mayoria de los lenguajes?
32
« en: Viernes 15 de Junio de 2007, 20:35 »
alguna otra recomendacion?
33
« en: Viernes 15 de Junio de 2007, 19:03 »
Hola, estoy buscando un libro del tipo "c# for c++ developers", quiero algo que explique las bondades de c# comparandolo con C++.
34
« en: Jueves 14 de Junio de 2007, 14:00 »
a que te referis con eliminar los datos de un arreglo?
35
« en: Jueves 14 de Junio de 2007, 00:45 »
el gcc me parece que no te compila si no es int.
36
« en: Martes 12 de Junio de 2007, 23:33 »
y mira depende de lo que queres hacer, HTML no es un lenguaje de programacion convencional, se labura mediante TAGS. Despues lo que podes hacer si te interesa algun lenguaje orientado a la web es PHP, ya que aca en argentina se trabaja mucho con eso.
37
« en: Domingo 10 de Junio de 2007, 13:53 »
¿Entonces para que instanciar una clase base como protected o private, si sólo como public se puede acceder? Bien, que secederia si le das a un compañero el código de clases que tenemos y hace asi: como instanciar una clase base como protected o private?, te referis a una clase derivada ahi? Sigo sin entender la diferencia de la herencia privada y protegida.  Estuve haciendo un par de pruebas y llegue a la siguiente conclusion, quisiera saber si es acertada o no. El tema del tipo de herencia si es privada, publica, o protegida entra en juego recien cuando es una herencia jerarquica, o sea si tengo 3 clases y se heredan jerarquicamente, es a partir de ahi. Si tengo solo 2 clases y no va a haber mas herencia no hay diferencia alguna. Por ej este codigo. Las lineas que estan comentadas son las que no permiten compilar segun el tipo de herencia. Herencia Publica #include <iostream> class base { private: int base_priv; public: int base_pub; base() { } protected: int base_prot; }; class derivada: public base { private: int deriv_priv; public: int deriv_pub; derivada() { deriv_priv = 1; deriv_pub = 2; deriv_prot = 3; //base_priv = 4; base_pub = 5; base_prot = 6; } protected: int deriv_prot; }; class derivada2: public derivada { private: int deriv2_priv; public: int deriv2_pub; derivada2() { //deriv_priv = 1; deriv_pub = 2; deriv_prot = 3; //base_priv = 4; base_pub = 5; base_prot = 6; } protected: int deriv2_prot; }; int main() { std::cout << "Hello world!" << std::endl; return 0; }
Herencia Protegida #include <iostream> class base { private: int base_priv; public: int base_pub; base() { } protected: int base_prot; }; class derivada: protected base { private: int deriv_priv; public: int deriv_pub; derivada() { deriv_priv = 1; deriv_pub = 2; deriv_prot = 3; //base_priv = 4; base_pub = 5; base_prot = 6; } protected: int deriv_prot; }; class derivada2: public derivada { private: int deriv2_priv; public: int deriv2_pub; derivada2() { //deriv_priv = 1; deriv_pub = 2; deriv_prot = 3; //base_priv = 4; base_pub = 5; base_prot = 6; } protected: int deriv2_prot; }; int main() { std::cout << "Hello world!" << std::endl; return 0; }
Herencia Privada #include <iostream> class base { private: int base_priv; public: int base_pub; base() { } protected: int base_prot; }; class derivada: private base { private: int deriv_priv; public: int deriv_pub; derivada() { deriv_priv = 1; deriv_pub = 2; deriv_prot = 3; //base_priv = 4; base_pub = 5; base_prot = 6; } protected: int deriv_prot; }; class derivada2: public derivada { private: int deriv2_priv; public: int deriv2_pub; derivada2() { //deriv_priv = 1; deriv_pub = 2; deriv_prot = 3; //base_priv = 4; //base_pub = 5; //base_prot = 6; } protected: int deriv2_prot; }; int main() { std::cout << "Hello world!" << std::endl; return 0; }
La diferencia que encontre es que con la herencia privada no puedo acceder en forma directa a los miembros de la clase base desde derivada2. Pero tanto la publica, como protegida no encontre diferencia.
38
« en: Domingo 10 de Junio de 2007, 00:48 »
todavia no me termina de cerrar el tema. O sea, si la herencia es publica, protegida o privada desde la derivada voy a poder acceder en forma directa a los miembros publicos y protegidos. Solo los privados son inaccesibles en forma directa. Lo que noto es que fuera de la clase derivada, dentro del main, solo puedo acceder en forma directa a los miembros publicos si y solo si la herencia es publica, pero si esta es privada o protegida no es posible. A lo que me refiero es a lo siguiente, estos codigos son similares. class base { private: int bas_priv; protected: int bas_proc; public: int bas_publ; }; class deriv : public base { private: int dev_priv; protected: int dev_proc; public: int dev_publ; deriv(int); }; deriv::deriv(int i) { dev_priv = i; dev_proc = i; dev_publ = i; bas_priv = i;//no puedo acceder bas_proc = i; bas_publ = i; }
class base { private: int bas_priv; protected: int bas_proc; public: int bas_publ; }; class deriv : protected base { private: int dev_priv; protected: int dev_proc; public: int dev_publ; deriv(int); }; deriv::deriv(int i) { dev_priv = i; dev_proc = i; dev_publ = i; bas_priv = i;//no puedo acceder bas_proc = i; bas_publ = i; }
class base { private: int bas_priv; protected: int bas_proc; public: int bas_publ; }; class deriv : private base { private: int dev_priv; protected: int dev_proc; public: int dev_publ; deriv(int); }; deriv::deriv(int i) { dev_priv = i; dev_proc = i; dev_publ = i; bas_priv = i;//no puedo acceder bas_proc = i; bas_publ = i; }
O sea, desde la definicion de las clases el acceso a los miembros no cambia aunque cambie el tipo de herencia(public, protected, private). Nunca voy a poder acceder a un miembro privado de una clase base, pero a los demas miembros si.
39
« en: Sábado 9 de Junio de 2007, 14:52 »
Hola, tengo una duda con respecto a la herencia privada y protegida. Herencia publica (class Derivada: public Base ) : Con este tipo de herencia se respetan los comportamientos originales de las visibilidades de la clase Base en la clase Derivada.
Herencia privada (clase Derivada: private Base) : Con este tipo de herencia todo componente de la clase Base, será privado en la clase Derivada (ojo! siempre será privado aunque ese dato fuese público en la clase Base)
Herencia protegida (clase Derivada: protected Base) : Con este tipo de herencia, todo componente publico y protegido de la clase Base, será protegido en la clase Derivada, y los componentes privados, siguen siendo privados. Por ej en la herencia privada, todos los miembros pasan a ser privados en la clase derivada, esto que quiere decir?, en que casos se utiliza este tipo de herencia? Lo que es herencia publica, creo que lo entiendo bien. Lo interpreto asi, corrijanme si estoy equivocado. class base { private: int a; protected: int b; public: int c; }; class derivada: public base { private: ... protected: ... public: ... };
Lo que entiendo es que desde la clase derivada puedo acceder en forma directa a lo que es "c" y "b", pero en forma indirecta a "a", con forma directa me refiero a que puedo hacer "c = 3;" desde la derivada, y con forma indirecta me refiero a que desde la derivada la unica forma de acceder a un miembro privado es a traves de una funcion (publica o protegida) de la clase base.
40
« en: Viernes 8 de Junio de 2007, 22:25 »
aca no hacemos tareas.
41
« en: Viernes 8 de Junio de 2007, 18:01 »
no.
42
« en: Miércoles 6 de Junio de 2007, 17:33 »
scanf te devuelve un 0 en caso de que hayas ingresado un caracter, y un 1 en caso de que ingresaste un numero.
43
« en: Lunes 4 de Junio de 2007, 22:08 »
postea el codigo aca con los tags, sino es muy molesto ayudarte asi.
44
« en: Lunes 4 de Junio de 2007, 04:01 »
Anion tiene que ser caracter a caracter? no puedo ingresar el nombre completo de una vez y luego mostrar caracter a caracter con un for? #include<stdio.h> #define MAX 15 int main() { char nombre[MAX+1]; int x; printf("Ingrese el nombre completo:"); fflush(stdin); gets(nombre); for(x=0;x<MAX;x++) { printf("Letra numero %d : %c\n", x+1, nombre[x]); } return 0; }
45
« en: Lunes 4 de Junio de 2007, 03:56 »
#include <stdio.h> int main() { char nombre[20]=""; int i; printf( "Elige el numero en el menu:\n\n" ); printf( "1 - Cargar fichero\n" ); printf( "2 - Guardar en un fichero\n" ); printf( "3 - Otras operaciones\n" ); printf( "4 - Mostrar datos\n" ); printf( "0 - Salir\n\n" ); printf( "Opcion: " ); printf( "\nHas elegido: %c", getchar() ); return 0; }
46
« en: Lunes 4 de Junio de 2007, 03:50 »
#include<stdio.h> #define MAX 3 int main() { char nombre[MAX]; int x; for(x=0;x<MAX;x++) { printf("Ingrese nombre:"); fflush(stdin); scanf("%c", &nombre[x]); } for(x=0;x<MAX;x++) { printf("%c", nombre[x]); } return 0; }
que raro probe este ejemplo y sale tres veces ingrese nombre y despues me tira hacia afuera!! estará bien? esta bien, lo que tenes que hacer es ingresar caracter a caracter. En el define puse 3 a modo de ejemplo, lo podes cambar por el valor que quieras. Un ppoco mas pulido seria asi. #include<stdio.h> #define MAX 3 int main() { char nombre[MAX+1]; int x; for(x=0;x<MAX;x++) { printf("Ingrese el %d caracter del nombre:", x+1); fflush(stdin); scanf("%c", &nombre[x]); } for(x=0;x<MAX;x++) { printf("%c", nombre[x]); } return 0; }
47
« en: Domingo 3 de Junio de 2007, 13:43 »
primero que para llamar a scanf es asi: scanf("%d",&numero);
48
« en: Sábado 2 de Junio de 2007, 23:50 »
Hola, alguien sabe como hacer en el IDE code blocks para pasarle algun parametro al compilador?, mi idea es desde el IDE que el compilador me genere el codigo en ensamblador. El parametro que quiero pasar es el "-S". Estuve probando tambien con el dev c y no puedo hacerlo desde el IDE, estoy haciendo pruebas y es bastante molesto hacerlo desde la linea de comandos.
49
« en: Sábado 2 de Junio de 2007, 19:29 »
existen varias, una muy buena es ECLIPSE, o sino una que no es free es JCREATOR.
50
« en: Sábado 2 de Junio de 2007, 19:22 »
#include<stdio.h> #define MAX 3 int main() { char nombre[MAX]; int x; for(x=0;x<MAX;x++) { printf("Ingrese nombre:"); fflush(stdin); scanf("%c", &nombre[x]); } for(x=0;x<MAX;x++) { printf("%c", nombre[x]); } return 0; }
Páginas: 1 [2] 3 4 ... 14
|
|
|
Mostrar Mensajes
