Mensajes

[PROHIBIDO]

FFS!!!!! Por dios, utiliza la etiqueta GeSHi para poner el código.

NUNCA, NUNCA, y vuelvo a repetir NUNCA uses GOTO. Utiliza bucles, pero no GOTO. hay cosas que quedan mal, como usar la biblioteca conio, pero goto más que quedar mal, está PROHIBIDO.

Deberías mirarte el formato que le puedes aplicar a cout, y pensar de qué forma puedes desplazar el mensaje hacia abajo, y mejor si utilizas mensajes diferentes.

Estuve buscando algo más de información para contrastar, y según leí, el estandar es vago a propósito en cuanto al tamaño de las variables. Esto se debe a que según el procesador, el tamaño de estas varía.

Según el procesador, un entero puede ocupar 4 bytes (32 bits) o bien 8 bytes (64 bits). La única definición al respecto es que un float no sea mayor que un double y este a su vez menor que un long double.

http://en.wikipedia.org/wiki/C_variable_types_and_declarations

¿Qué tal usar la sección de programación general para ello?

Ahí lo dejo

Esto... en C si mal no recuerdo fopen creaba el fichero si no existía, por tanto, únicamente necesitarías crear dicho fichero, y con fprintf guardar ahí la cadena que hayas leído.

Más o menos la estructura del programa sería:

Abrir fichero --> pedir cadena --> imprimir cadena en fichero --> cerrar fichero.

Es una idea interesante, pero le veo una gran pega:

Creo que no me equivoco al asumir que los ejercicios a cierto nivel no varían demasiado (trabaja con estructuras de datos, haz un programa básico de manejo de ficheros etc etc etc) y este post podría convertirse en "el rincon del vago" para códigos de C/C++. Algunos únicamente vendrían a copiarse tareas.

Digo lo que digo porque tras un tiempo frecuentando esta sección, he visto muchas veces que se ha pedido lo mismo: ejercicios con estructuras de datos, algunos de manejo básico del lenguaje...

Buscando en google "ANSI C Referenfe" encontré en la primera entrada (en la sección de variables) lo siguiente:

Type     Size     Range
unsigned char    8 bits    0 to 255
char    8 bits    -128 to 127
unsigned int    16 bits    0 to 65,535
short int    16 bits    -32,768 to 32,767
int    16 bits    -32,768 to 32,767
unsigned long    32 bits    0 to 4,294,967,295
long    32 bits    -2,147,483,648 to 2,147,483,647
float    32 bits    1.17549435 * (10^-38) to 3.40282347 * (10^+38)
double    64 bits    2.2250738585072014 * (10^-308) to 1.7976931348623157 * (10^+308)
long double    80 bits    3.4 * (10^-4932) to 1.1 * (10^4932)

En cualquier caso, si mal no tengo entendido, la longitud de algunos tipos puede variar dependiendo de la arquitectura del procesador.

[Compilar/ejecutar el programa con Code::Blocks]

[El código de los dos programas usados en este pequeño tutorial se encuentran al final del post [codi]]

Para muchos se que no estoy contando nada nuevo, pero el motivo de este post es sobretodo para gente que empieza a programar, especialmente para aquellos que creen necesitar agún tipo de pausa al ejecturar programas para ver resultados (system(pause), getchar, getch etc).

Para este problema se nos plantean, entre otras, dos soluciones:

• Compilar/ejecutar el programa con Code::Blocks [cdbl]
• Ejecutar el programa una vez compilado vía la consola de windows [cmdw]

Vía Code::Blocks [cdbl]

Code::Blocks es un IDE (entorno de desarrollo) con compilador (podemos elegir qué compilador usar),  open source, cross plataform y gratuito. Una de sus muchas ventajas, es que cuando compilamos y ejecutamos un programa en este IDE, el propio entorno retiene la ventana mostrando el return y el tiempo empleado en la ejecución del programa (tiempo total, no sólo de ejecución de instrucciones, cuenta también el tiempo que tardamos en introducir datos vía scanf, cin y demás instrucciones que nos soliciten que pulsemos algo).

Dado que esto no es un manual de como usar Code::Blocks, me centraré en la compilación y ejecución con este entorno. Supongamos que tenemos ya un programa creado en Code::Blocks:



El recuadro rojo señala donde debemos hacer click para compilar y/o ejecutar nuestro programa. En la siguiente imagen muestro como hacer lo mismo vía el menú "Build".



El resultado de ambas es la siguiente, donde vemos que el programa se ha ejecutado, nos ha dado unos resultados y Code::Blocks lo ha detenido.

Vía consola de windows [cmdw]

Otra solución reside en ejecutar los programas vía el cmd de Windows. A diferencia de si hiciésemos doble click en el programa ya compilado (que abriría una ventana y la cerraría inmediatamente después de su uso) ejecutarlo de esta forma permite visualizar los textos, resultados etc que el programa imprima por pantalla sin que desaparezca en un instante. Procedo a explicar como:

Asumamos que ya tenemos nuestro programa compilado y deseamos probarlo. Para ello, vamos al menú inicio y buscamos cmd:




Le damos a Enter y nos aparecerá una ventana similar a esta:




En principio la ruta en la que nos encontramos es la de nuestro usuario, pudiendonos mover de directorio con el comando cd y obtener el contenido de un directorio con el comando dir:




Una vez nos encontramos en el directorio de nuestro programa, procedemos a ejecutarlo de la siguiente forma:
nombre del programa.extensión argumento 1 argumento 2....

En este caso, el programa recibe un archivo txt como argumento:





y el resultado de la ejecución es:

Conclusión

Como habréis podido observar, es bastante sencillo ejecutar programas sin necesidad de instrucciones para detenerlos al finalizar, ahorrando instrucciones como system (pause), getchar, getch ( y por ende, NO necesitamos conio.h (como librería obsoleta)).

¿Comentarios, dudas, sugerencias, feedback en general?


[codi]

class_pila.cpp

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <fstream>
using namespace std;

class pila{

struct node{
   int num;
   struct node *seg;
   };

node * cap;

public:
   pila();
   ~pila();
   void push(int num);
   int pop();
   int top() const;
   bool buidap() const;
   pila & operator << (const int num);
};


pila::pila(){
   cap=0;
}

pila::~pila(){
   while(cap){
   node *aux=cap;
   cap=cap->seg;
   delete aux;
   }
}

bool pila::buidap() const{
return (!cap);
}

int pila::top() const{
   if(!buidap())
       return cap->num;
   else return -666;
}

int pila::pop(){
   if(cap){
       node *aux=cap;
       cap=cap->seg;
       int numaux=aux->num;
       delete aux;
       return numaux;
   }
   else return -666;
}

void pila::push(int n){
   node *nou;
   nou=new node;
   nou->num=n;
   nou->seg=cap;
   cap=nou;

}

pila & pila::operator << (const int num){
push(num);
return *this;}

int main(){
   pila p1;
   int num;
   ifstream fitx;
   fitx.open("class_pila.txt");

   if(!fitx){
       cerr << "error al abrir el fichero" << endl;
       return -1;}

   while(fitx >> num){
   cout << num << endl;
   //p1.push(num);
   p1 << num;
   }

   if(!p1.buidap())
       cout << "pila con elementos" << endl;

   while(!p1.buidap()){
   cout << p1.pop() << endl;
   }

   if(p1.buidap())
       cout << "WARNING: pila vacia" << endl;

   fitx.close();
   return 0;
}


class_pila2.cpp

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <fstream>
using namespace std;

class pila{

struct node{
   int num;
   struct node *seg;
   };

node * cap;

public:
   pila();
   ~pila();
   void push(int num);
   int pop();
   int top() const;
   bool buidap() const;
   pila & operator << (const int num);
};


pila::pila(){
   cap=0;
}

pila::~pila(){
   while(cap){
   node *aux=cap;
   cap=cap->seg;
   delete aux;
   }
}

bool pila::buidap() const{
return (!cap);
}

int pila::top() const{
   if(!buidap())
       return cap->num;
   else return -666;
}

int pila::pop(){
   if(cap){
       node *aux=cap;
       cap=cap->seg;
       int numaux=aux->num;
       delete aux;
       return numaux;
   }
   else return -666;
}

void pila::push(int n){
   node *nou;
   nou=new node;
   nou->num=n;
   nou->seg=cap;
   cap=nou;

}

pila & pila::operator << (const int num){
push(num);
return *this;}

int main(int argc, char **argv){
   pila p1;
   int num;
   ifstream fitx;
   fitx.open(argv[1]);

   if(!fitx){
       cerr << "error opertura fitxer" << endl;
       return -1;}

   while(fitx >> num){
   cout << num << endl;
   //p1.push(num);
   p1 << num;
   }

   if(!p1.buidap())
       cerr << "pila amb elements" << endl;

   while(!p1.buidap()){
   cout << p1.pop() << endl;
   }

   if(p1.buidap())
       cerr << "WARNING: pila buida" << endl;

   fitx.close();
   return 0;
}


contenido de class_pila.txt:

Código [Seleccionar] Expandir

1
5
6
7
10
20
50

No tienes por qué guardar los números que te introducen, simplemente ves comprobando a cada introducción cual es el máximo

Por desgracia parece que en España, el derecho a huelga de unos significa joderles el día a otros, de la forma que sea.

Con tu segundo código, compila si le quitas el system("pause"). En C funcionaría, pero en C++ me parece que no puedes hacer llamadas al sistema de esta forma (alguien que concrete esto, por favor). Por otro lado, si usas codeblocks no necesitas un pause, ya que cuando compilas y ejectuas dentro del propio IDE él mismo para el programa después que este finalice.

Turbo C, dev c++ y alguno más están obsoletos, como Littlehorse (y otros) han dicho ya en muchas ocasiones, es mejor utilizar Codeblocks o Visual C++

[...]

En lo personal, te recomendaría que instales otro entorno de trabajo:

• Visual C++ Express
• Code::Blocks

Por otro lado, a diferencia de C, las librerías suelen incluirse sin el .h, como ya has visto.

Sobre el namespace, te recomendaría que leyeses sobre espacio de nombres. Como pequeño resumen se podría decir que el espacio de nombres es el apellido de las variables, algo que diferencia variables de un mismo nombre. Según tengo entendido no es algo que se emplee demasiado a menos que trabajes en proyectos grandes / con diferentes personas que es cuando se pueden dar casos de variables homónimas.

EDIT: Codeblocks no te avisaba del error? ¿qué compilador dentro de codeblocks estás usando? Mira también de activar en las opciones del compilador (settings -> compiler and debugger) lo siguiente: -Wall, -pedantic.