Porqué dejar C y programar en C++?

[X.Cyclop]

Porqué dejar C y programar en C++?




Un poco de Historia:

El lenguaje C fue desarrollado por Kernighan y Ritchie en 1972, en la ATT. El lenguaje C++ se comenzó a desarrollar en 1980. Su autor fue B. Stroustrup, también de la ATT. Al comienzo era una extensión del lenguaje C que fue denominada C with classes. Este nuevo lenguaje comenzó a ser utilizado fuera de la ATT en 1983. El nombre C++ es también de ese año, y hace referencia al carácter del operador incremento de C (++). Ante la gran difusión y éxito que iba obteniendo en el mundo de los programadores, la ATT comenzó a estandarizarlo internamente en 1987.

En la actualidad, el C++ es un lenguaje versátil, potente y general. Su éxito entre los programadores profesionales le ha llevado a ocupar uno de los primeros puestos como herramienta de desarrollo de aplicaciones. El C++ mantiene las ventajas del C en cuanto a riqueza de operadores y expresiones, flexibilidad, concisión y eficiencia. Además, ha eliminado algunas de las dificultades y limitaciones del C original.

¿Que se pretende?

Si bien es cierto, con el C se han hecho grandes proyectos, inclusive C++ nació de C y, por ejemplo, Java nació de C++; es estúpido pensar que por este hecho C tenga ventajas sobre el C++. Si así fuera, nadie se habría tomado la molestia de evolucionar el C en C++.

Por otro lado, las personas que están comenzando en el mundo de la programación, creen que al comenzar (valga la redundancia) con un lenguaje “Antiguo”, va ha ser más fácil de entender. Pero esto lastimosamente no es cierto, les aseguro que es más fácil comenzar con C++, que con C o Pascal o Fortran o Basic u otros lenguajes que ya cumplieron su ciclo.

También pretendo mostrar los fundamentos del C++ a partir del C. También mostrar algunas de las modificaciones que hizo C++ al C, y las nuevas características ante este.


Manos a la obra

El C++ es un lenguaje procedural (orientado a algoritmos) y orientado a objetos. Como lenguaje procedural es parecido al C y es compatible con él, aunque ya he dicho que presenta ciertas ventajas. Como es un lenguaje orientado a objetos se basa en una filosofía completamente diferente que la del C, pero más robusta.

Comencemos entonces a ver cuales son esas modificaciones del C hacia el C++. Normalmente se trata de aumentar la capacidad del lenguaje y la facilidad de programación en un conjunto de detalles concretos basados en la experiencia de muchos años.

Entonces es importante ver un listado de las principales modificaciones que se han implementado en el C++:

●Cambio en la extensión del nombre de los ficheros
●Declaración simplificada de variables tipo enumeración
●Declaración simplificada de variables correspondientes a estructuras
●Comentarios introducidos en el programa
●Mayor flexibilidad en la declaración de variables
●Scope o visibilidad de variables
●Especificador const para variables
●Especificador const para punteros
●Conversiones explícitas de tipo
●Especificador inline para funciones
●Sobrecarga de funciones
●Valores por defecto de parámetros de una función
●Variables de tipo referencia
●Operadores new y delete para gestión dinámica de memoria
●Punteros de tipo void
●Nueva forma de realizar las operaciones de entrada y salida
●Funciones con número de parámetros variable

Nota: Es importante aclarar que solo se verán ejemplos de los cambios más importantes, ya que este es solo un texto introductorio. Para poder explicar todas las modificaciones y ventajas del C++ sobre el C, se llenarían libros.

Lo primero es el cambio en la extensión *.c, que ahora es *.cpp. Aunque sea un cambio aparentemente estúpido, es importante a la hora de compilar los códigos fuente, ya que esto indica que compilador se va ha usar: si el de C o el de C++.

Es importante aclarar que C++ mantiene una compatibilidad con C, lo cual indica que C++ permite que se haga casi todo lo que se podía en C. Pero También es de aclarar que aunque esto sea posible C++ dispone de una mejor forma de realizar esas tareas. Esto puede ser útil para los programadores que se acostumbraron a C, ya que les permite ir entrando y familiarizándose de a pocos con el C++, combinando las instrucciones y códigos del los dos lenguajes, utilizando obviamente el compilador de C++.

EJEMPLOS

Es difícil explicar en que consiste las ventajas del C++ frente al C. Por esto, y para un mayor entendimiento, es casi necesario mostrar códigos de programas que hagan lo mismo, pero que estén en C y en C++. Estos, claro está, resaltando algunas de las modificaciones listadas anteriormente.

Mayor flexibilidad en la declaración de variables

En cuanto a declaración de variables C++ es muy parecido a C, pero con una importante diferencia. En C las variables tenían que ser declaradas al comienzo de un bloque, antes de la primera sentencia ejecutable de dicho bloque. En C++ las variables pueden ser declaradas en cualquier lugar de un bloque. Esto hace que la declaración de las variables se haga, en el sitio más cercano de donde se van a utilizar por primera vez.
Un caso relevante son los bucles for. En C++ la variable que sirve de contador al bucle puede declararse e inicializarse en la propia sentencia for. Por ejemplo, considérese el siguiente bucle para sumar los elementos de un vector:

Código:

/* Sumar elementos de un vector en C */
#include<stdio.h>
main()
{
    int i;
    int a[]={1,2,3,4,5};
    for(i=0;i<5;i++)
        suma=suma+a[i];
        printf("i es %d\n",i);
    getchar();
}

Código:

// Sumar elementos de un vector en C++
#include<iostream.h>
main()
{
    int a[]={1,2,3,4,5};
    for(int i=0;i<5;i++)
        suma+=a[i];
    cout<<"\ni es "<<i;
    getchar();
}

Scope o visibilidad de variables

La visibilidad de una variable es la parte del programa en la que esa variable está definida y puede ser utilizada. La duración hace referencia al tiempo que transcurre entre la creación de una variable y el instante en que es destruida. En general la visibilidad de una variable declarada dentro de un bloque abarca desde el punto en el que se define hasta que el bloque finaliza.
Si la declaración de una variable esta por fuera de todos los bloques, incluyendo en bloque main, es visible en toda parte del programa hasta que este culmina; a menos de que una variable local, en cualquier bloque anidado, oculte esta variable global, llamándose igual que esta. Las reglas de duración y visibilidad de C++ son similares a las de C.
Osea que, una variable local declarada dentro de un bloque oculta una variable global del mismo nombre u otra variable local también del mismo nombre declarada en un bloque más exterior. La ventaja que tiene C++ en este caso, es poder referenciar variables globales que este ocultas, por una local, utilizando el operador de resolución de ámbito (::). Por ejemplo, considérese el siguiente caso de ocultación de variables:

Código:

/* Ocultación de variables en C */
#include<stdio.h>
int x = 2.0;
main()
{
    printf("%d\n", x);/*Escribe 2*/
    {
        printf("%d\n", x);/*Escribe 2*/
        int x = 3.0;
        printf("%d\n", x);/*Escribe 3*/
        /*Ahora deseamos imprimir la variable x global
        pero es imposible hacerlo desde aquí*/
        printf("%d\n", x);/*Escribe 3*/
    }
    printf("%d", x);/*Escribe 2*/
    getchar();
}

Código:

// Ocultación de variables en C++
#include<iostream.h>
int x = 2.0;
main()
{
    cout<<x<<endl;   //Escribe 2
    {
        cout<<x<<endl;    //Escribe 2
        int x = 3.0;
        cout<<x<<endl;    //Escribe 3
        /*Ahora deseamos imprimir la variable x global
        por lo que utilizamos el operador de resolución de ámbito*/
        cout<<::x<<endl;    //Escribe 2
    }
    cout<<x<<endl;    //Escribe 2
    getchar();
}

Especificador const para variables

En C++ el especificador const se puede utilizar con variables y con punteros. Si una variable se define como const indica que que su valor no va a cambiar durante toda la ejecución del programa. Si en alguna sentencia del programa se intenta variar el valor de una variable definida como const, el compilador produce un mensaje de error (obviamente). Las variables de este tipo pueden ser inicializadas pero no pueden pasar , después de la inicialización, por un proceso de asignación, o sea, con el operador =.
Las variables declaradas como const tienen importantes diferencias con las constantes simbólicas definidas con la directiva #define del preprocesador. Porque aunque ambas representan valores que no se puede cambiar, las variables const están sometidas a las mismas reglas de visibilidad y duración que las demás variables del lenguaje.
Las variables const de C++ pueden ser utilizadas para definir el tamaño de un vector en la declaración de éste, cosa que no está permitida en C. Juzguen este pequeño ejemplo:

Código:

/* Asignar tamaño a un array en C */
#define SIZE=5
#include<stdio.h>
main()
{
    char cs[SIZE] ;
    getchar();
}

Código:

// Asignar tamaño a un array en C++
#include<iostream.h>
main()
{
    const int SIZE=5;
    char cs[SIZE] ;
    getchar();
}

[X.Cyclop]

Conversiones explícitas de tipo

Además de las conversiones implícitas de tipo, del lenguaje C, que tienen lugar al realizar operaciones aritméticas entre variables de distinto tipo y en las sentencias de asignación; el lenguaje C++ dispone de otra conversión explícita de tipo con una notación similar a la de las funciones y más sencilla que la del cast. Se utiliza para ello el nombre del tipo al que se desea convertir seguido del valor a convertir entre paréntesis.

Código:

/* Conversión explicita en C */
#include<stdio.h>
main()
{
    double x=2.5;
    int y=(int)(x);
    printf("y tiene x entero: %d",y);
    getchar();
}

Código:

// Conversión explicita en C++
#include<iostream.h>
main()
{
    double x=2.5;
    int y=int(x);
    cout<<"y tiene x entero: "<<y;
    getchar();
}

Sobrecarga de funciones

La sobrecarga (overload) de funciones consiste en declarar y definir varias funciones distintas que tienen un mismo nombre, pero que difieren en cuanto a sus argumentos. En el momento de la ejecución se llama a una u otra función dependiendo del número y/o tipo de los argumentos actuales de la llamada a la función.
La sobrecarga de funciones no permite que se hagan dos funciones con diferente valor de retorno, y con un mismo numero de argumentos. De hecho, el valor de retorno no influye en la determinación de la función que es llamada; sólo influyen el número y tipo de los argumentos.
Tampoco se admite que la diferencia sea el que en una función un argumento se pasa por valor y en otra función ese argumento se pasa por referencia.
La sobrecarga de funciones es algo muy importante, aunque su relevancia se verá mejor en el siguiente ejemplo:

Código:

/* Ejemplo de función que no se puede sobrecargar en C */
#include<stdio.h>
#include<math.h>
double potencia(double x)
{
return pow(x,x);
}
double potencia2(double x,double y)
{
return pow(x,y);
}
main()
{
    double a=2,b=3,r1=0,r2=0;
    r1=potencia(a);
    r2=potencia2(a,b);
    printf("Potencia de %f a la %f = %f",a,a,r1);
    printf("\nPotencia de %f a la %f = %f",a,b,r2);
    getchar();
}

Código:

// Ejemplo de función sobrecargada en C++
#include<iostream>
#include<math.h>
using namespace std;
double potencia(double x)
{
return pow(x,x);
}
double potencia(double x,double y)
{
return pow(x,y);
}
main()
{
    double a=2,b=3,r1=0,r2=0;
    r1=potencia(a);
    r2=potencia(a,b);
    cout<<"Potencia de "<<a<<" a la "<<a<<" = "<<r1
        <<"\nPotencia de "<<a<<" a la "<<b<<" = "<<r2<<endl;
    getchar();
}

Otro ejemplo:

Código:

/* Ejemplo de función que no se puede sobrecargar en C */
#include <stdio.h>
#include <string.h>
void string_copy(char *copia, const char *original)
{
	strcpy(copia, original);
}
/* Se pierde tiempo y claridad declarando otra función
que hace lo mismo, pero recibe diferentes argumentos*/
void string_copy2(char *copia, const char *original, const int longitud)
{
	strncpy(copia, original, longitud);
}
static char string_a[20], string_b[20];
main()
{
	string_copy(string_a, "Aquello");
	string_copy2(string_b, "Esto es una cadena", 4);
	printf("%s y %s\n",string_b,string_a);
	getchar();
}

Código:

// Ejemplo de función sobrecargada en C++
#include <iostream>
#include <string.h>
using namespace std;
void string_copy(char *copia, const char *original)
{
	strcpy(copia, original);
}
void string_copy(char *copia, const char *original, const int longitud)
{
	strncpy(copia, original, longitud);
}
static char string_a[20], string_b[20];
main()
{
	string_copy(string_a, "Aquello");
	string_copy(string_b, "Esto es una cadena", 4);
	cout << string_b << " y " << string_a <<endl;
	getchar();
}

Valores por defecto de parámetros de una función

En C se espera encontrar una correspondencia exacta entre la lista de argumentos actuales (llamada) y la lista de argumentos formales (declaración y definición) de una función o método.
En C++ la situación es diferente pues se pueden definir valores por defecto para todos o algunos de los argumentos formales. Después, en la llamada, en el caso de que algún argumento esté ausente de la lista de argumentos actuales, se toma el valor asignado por defecto a ese argumento. Por ejemplo, en este caso se asigna a uno de los valores de la función, el valor por defecto 2, lo cual permite que se pueda invocar esta función con un solo valor:

Código:

// Valores por defecto en C++
#include<iostream>
#include<math.h>
using namespace std;
double potencia(double x,double y=2)
{
return pow(x,y);
}
main()
{
    double a=2,b=3,r1=0,r2=0;
    //esto generaría errores en C
    r1=potencia(a);
    r2=potencia(a,b);
    cout<<"Potencia de "<<a<<" a la "<<a<<" = "<<r1
        <<"\nPotencia de "<<a<<" a la "<<b<<" = "<<r2<<endl;
    getchar();
}

Variables de tipo referencia

Para un mayor entendimiento de esta modificación se presentará, de una vez, la manera en que se pasaban argumentos por referencia en C; y luego aclararemos lo nuevo del C++ (incluyendo el código respectivo). Para ello se va a utilizar la función permutar():

Código:

/* Variables por referencia en C */
#include <stdio.h>
#include <stdlib.h>
void main(void)
{
int i = 1, j = 2;
void permutar(int *a, int *b);
printf("\ni = %d, j = %d", i, j);
permutar(&i, &j);
printf("\ni = %d, j = %d", i, j);
}
void permutar(int *a, int *b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}

La cuestión, en C, para pasar parámetros por referencia está en el uso de punteros. Al pasar la dirección de la variable, ésta es accesible desde dentro de la función y su valor puede ser modificado. De igual manera, si dentro de una función hay que modificar un puntero habrá que pasar su dirección como argumento, esto es, habrá que pasar un puntero a otro puntero.

C++ ofrece una nueva forma de pasar argumentos por referencia a una función, en donde no es necesario utilizar (dentro de la función) el operador indirección (*) para acceder al valor de la variable que se quiere modificar.

Esto se hace mediante de un nuevo tipo de dato (que no existe en C) llamado tipo referencia. Las variables referencia se declaran por medio del carácter ámpersan (&). Por lo demás, son variables normales que contienen un valor numérico o alfanumérico. El ejemplo anterior convertido a C++ es el siguiente:

Código:

//  Variables por referencia en C++
#include <iostream>
#include <stdlib.h>
using namespace std;
main()
{
    int i = 1, j = 2;
    void permutar(int &a, int &b); // los argumentos son referencias
    cout<<"\ni = "<<i<<", j = "<<j;
    permutar(i,j); // los argumentos no llevan (*) ni (&)
    cout<<"\ni = "<<i<<", j = "<<j;
    getchar();
}
void permutar(int &a, int &b) // los argumentos son referencias
{
    int temp;
    temp = a; // no hace falta utilizar
    a = b; // el operador indirección (*)
    b = temp;
}

Los dos programas dan idéntico resultado, pero el de C++ tiene una ventaja: no hay que utilizar el operador indirección dentro de la función permutar(). C++ permite pasar argumentos por referencia sin más que anteponer el carácter (&) a los argumentos correspondientes, tanto en el prototipo como en el encabezamiento de la definición. Cuando se invoca esta función los argumentos se ponen directamente, sin anteponerles ningún carácter u operador.
En C++ existe realmente un tipo llamado referencia que va más allá del paso de argumentos a funciones. Las variables de tipo referencia se declaran con el operador (&) y deben ser inicializadas a otra variable o a un valor numérico. Por ejemplo:

int i=2;
int& iref = i; // declaración de referencia válida

Donde la variable i en una variable entera normal, y la variable por referencia iref es un especie de alias que representa esa variable. Entonces, si se modifica, por ejemplo, la variable i, también se modifica la variable iref, y viceversa. La diferencia con un puntero es que si ya se declaró una variable por referencia a una variable, no puede ser re-asignada para referenciar a otra variable. El principal uso de las variables referencia es como valor de retorno o argumentos de funciones. Pero, ¿para que puede ser útil esto?, considérese el siguiente ejemplo; se desea que se evalúen dos valores, y que al mayor valor se le asigne el numero 0, utilizando una función para dicho propósito:

Código:

//Referencias en funciones en C++
#include <iostream>
#include <stdlib.h>
using namespace std;
main()
{
    int i = 10, j = 8;
    int maxref(int &a, int &b); // los argumentos son referencias
    cout<<"\ni = "<<i<<", j = "<<j;
    //Esto es muy inusual en cuanto a invocación de variables
    //Pero en C++ no genera errores
    maxref(i,j)=0;
    cout<<"\ni = "<<i<<", j = "<<j;
    getchar();
}
int& maxref(int& a, int& b)
{
    if (a >= b)
    return a;
    else
    return b;
}

En este ejemplo se asigna 0 al alias de un valor mayor. Este mismo efecto puede conseguirse mediante punteros, pero con referencias resulta mucho más sencillo.

[X.Cyclop]

Operadores new y delete para gestión dinámica de memoria

Con los operadores new y delete se tiene entera libertad para decidir crear o destruir las variables cuando se necesite. Además una variable creada con new puede ser utilizada y manipulada por instrucciones de otros bloques.
¿Pero no existe luego una función llamada malloc()? Un aspecto diferente con la función malloc(), que es el método más utilizado para reservar dinámicamente memoria en C, es que ésta devuelve un puntero a void (*void) que es después convertido al tipo de variable que se desea. Esa conversión se evita con new, eliminando así una posible fuente de problemas.
Se puede utilizar el operador new para crear variables de cualquier tipo. New devuelve, en todos los casos, un puntero a la variable creada.
Cuando una variable ya no es necesaria se destruye con el operador delete para poder utilizar la memoria que estaba ocupando, mediante una instrucción del tipo:

Código:

delete p;

Considerense los siguientes ejemplos:

Código:

/* Asignación dinámica de memoria en C */
#include<stdio.h>
#include<malloc.h>
#include<string.h>
main()
{
    char *str=NULL;
    /*Pide memoria para una cadena de 10 caracteres*/
    str=(char *) malloc(10*sizeof(char));
    strcpy(str,"Hola");
    printf("La cadena es %s",str);
    free(str);/*Libera la memoria*/
    getchar();
}

Código:

// Asignación dinámica de memoria en C++
#include<iostream.h>
#include<string.h>
main()
{
    char *str=NULL;
    //Pide memoria para una cadena de 10 caracteres
    str=new char(10);
    strcpy(str,"Hola");
    cout<<"La cadena es “<<str;
    delete str;//Libera la memoria
    getchar();
}

Nueva forma de realizar las operaciones de entrada y salida

En C++ además de las funciones printf() y scanf(), que siguen estando vigentes, se pueden utilizar los operadores cin y cout. Para utilizar estos nuevos operadores es necesario incluir la librería iostream.h con la instrucción #include <iostream.h>. Así en un programa en C habría que hacer
algo de este estilo:

Código:

char nombre;
int num=2;
printf ("Introduzca el nombre del fichero %d: ", num);
scanf (" %s", nombre)

En C++ podría escribirse así:

Código:

char nombre;
int num=2;
cout << "Introduzca el nombre del fichero " << num << ": ";
cin >> nombre;

Pero aquí ¿cuál es la mejora?, si nos fijamos con los operadores << y >> (que además se pueden sobrecargar) no es necesario especificar el tipo de dato que va a ser impreso o leído, asociándolo con un formato determinado. Es el propio programa el que decide el tipo de dato en tiempo de ejecución. Estos operadores están sobrecargados de tal manera que admiten tanto los tipos predefinidos como aquellos tipos de datos definidos por el usuario.
Para poder escribir o leer desde ficheros es necesario incluir la librería <fstream.h>. A continuación se presenta un sencillo ejemplo en el que primero se escriben unas frases en un fichero y después se imprimen en la pantalla leídas desde ese fichero:

Código:

/* E/S en C*/
#include<stdio.h>
main()
{
    FILE *out;
    out=fopen("fichero.txt","w+");
    fputs("Es mas difícil crear, declarar e inicializar flujos en C",out);
    fclose(out);
    // Ahora comienza la lectura
    FILE *in;
    in=fopen("fichero.txt","r");
    char line[81];
    fgets(line,sizeof(line),in);
    printf("%s",line);
    fclose(in);
    getchar();
}

Código:

// E/S en C++
#include <fstream>
#include <iostream>
using namespace std;
main()
{
    ofstream out("fichero.txt"); // se define un flujo de salida a fichero
    out<<"Es mas fácil crear flujos de E/S en C++";
    out.close();
    // Ahora comienza la lectura
    ifstream in("fichero.txt"); // se define un flujo de entrada de fichero
    char line[81];
    in.getline(line,81);
    cout<<line<<endl;
    getchar();
}

Como pueden observar, lo que se hace es declarar flujos de E/S, con lo cual se puede utilizar, en este caso, el operador << para crear el canal al archivo, mediante el cual se escribe en el, como si fuera una salida normal con el cout.

El ejemplo anterior necesita algunas explicaciones extras; se declara un objeto (ya esto hace parte de la llamada POO) del tipo ofstream llamado out. Este será un objeto que almacenará la información necesaria para llevar los datos de salida hasta un fichero llamado fichero.txt. Esto es el equivalente a utilizar la función fopen() de C para abrir un fichero de escritura de datos.
Hay que darse cuenta de que la primera vez que se abre el fichero se abre en modo de escritura. Por eso hay que cerrarlo para después poder abrirlo en modo de lectura. Para realizar esta última operación es necesario declarar un objeto, al que se llama in, del tipo ifstream. El endl que hemos venido manejando, hace que se imprima un carácter de salto de línea y que se vacíe el buffer de salida de modo inmediato.
La función getline se utiliza para leer los datos que se introduzcan desde el teclado de forma similar a la que lo haría la función scanf() leyendo una línea completa hasta el '\n'.


AGREGRACIONES DEL C++

Como ya se dijo este texto solo pretende mostrar las características del C++ frente al C. Pero no sobra mostrar una lista de las funcionalidades que no tiene C, y que en su mayoría se deben al la Programación Orientada a Objetos (POO):

●Clases y Objetos
●Clase con y sin secciones privadas
●Expansión inline
●Entrada y salida de datos mejorada
●Operadores new y delete con clases
●Constructores y destructores
●Clases y funciones friend
●El puntero this
●Sobrecarga de operadores
●Clase cadena para manejo de cadenas de caracteres
●Objetos miembro de otros objetos
●Herencia simple y herencia múltiple
●Clases base virtuales
●Polimorfismo
●Funciones miembro width(), precision() y fill()
●Manipuladores de entrada/salida
●Sobrecarga de los operadores de entrada/salida (<< y >>)
●Excepciones


http://foro.elhacker.net/index.php/topic,92989.0.html

[blackwind]

Muy bueno
Creo que deberian de poner este tema como "sticky".
No me molestaria que me borraran mi post

saludos,

[puppys]

Exelente

Iniciado por blackwind

Muy bueno
Creo que deberian de poner este tema como "sticky".
No me molestaria que me borraran mi post
saludos,

Totalmente de acuerdo

suerte

[GeoAvila]

sus deseos son ordenes...
ya vemos que podemos hacer...

nos vemos..

[Mithrandir]

Solo un par de comentarios X.Cyclop:

1) Veo que es un reporte bastante completo, felicidades!
2) ¿Lo escribiste tu? Si lo has tomado de otro lado sería conveniente citar la fuente para evitar problemas (anteriormente se han dado casos de plagio)

No me lo tomes a mal, pregunto con la mejor de las intenciones.

[GeoAvila]

up's.. creo que el texto proviene de este manual..

http://64.233.187.104/search?q=cache...nt+%26b)&hl=es

nos vemos..

[cabeza_nispero]

¡¡¡ Yo lo flipo !!!

Todo eso de "C++" no es demasiado importante, muchos lenguajes lo implementan... Y en cualquier caso comparar una función hecha en C con su traducción "literal" (que no es necesaria por cierto) a C++ me parece absurdo. Donde C++ sobresale es en POrientada_a_Objetos, PGenérica, la STL, grandes proyectos, ... En funciones pequeñas, es mejor usar C, es más rápido un puts() que un cout.

Aparte, lo importante:
¿Qué hay de las plantillas, es decir, la programación genérica, donde C++ es el que sobresale por mucho? ¿Qué hay de la STL? ¿De las nuevas librerías? ¿Del nuevo estándar?

Aquí se ha hablado del C++ clásico, del que se estudia en la universidad, del C++ que se conoce por ahí, no del C++ que se usa.

[X.Cyclop]

Iniciado por Mithrandir

Solo un par de comentarios X.Cyclop:

1) Veo que es un reporte bastante completo, felicidades!
2) ¿Lo escribiste tu? Si lo has tomado de otro lado sería conveniente citar la fuente para evitar problemas (anteriormente se han dado casos de plagio)

No me lo tomes a mal, pregunto con la mejor de las intenciones.

No, yo no robo nada ni soy lammer. Vean hasta abajo del artículo puse el link de la fuente: http://foro.elhacker.net/index.php/topic,92989.0.html

Yo soy de los pocos que respeta derechos de autor y pone fuentes.

Ojalá lo hubiera escrito yo. Apenas voy en Php, me falta para llegar a C y C++. jeje

Suerte.

[GeoAvila]

Iniciado por X.Cyclop

No, yo no robo nada ni soy lammer. Vean hasta abajo del artículo puse el link de la fuente: http://foro.elhacker.net/index.php/topic,92989.0.html

Yo soy de los pocos que respeta derechos de autor y pone fuentes.

Ojalá lo hubiera escrito yo. Apenas voy en Php, me falta para llegar a C y C++. jeje

Suerte.

nos vemos..

[blackwind]

Iniciado por cabeza_nispero

¡¡¡ Yo lo flipo !!!

que es eso?

Iniciado por cabeza_nispero

Todo eso de "C++" no es demasiado importante, muchos lenguajes lo implementan... Y en cualquier caso comparar una función hecha en C con su traducción "literal" (que no es necesaria por cierto) a C++ me parece absurdo. Donde C++ sobresale es en POrientada_a_Objetos, PGenérica, la STL, grandes proyectos, ... En funciones pequeñas, es mejor usar C, es más rápido un puts() que un cout.

Estoy en desacuerdo. Porque el post se trata de actualizarte de C a C++ , no de C a otro lenguaje orientado a objetos como Java o C#, asi que eso si es muy importante.
Ademas, si vas a hacer una funcion pequeña, estoy seguro que el ojo humano no puede notar la diferencia de si usaste puts() o std::cout......

Saludos,

[Eternal Idol]

El uso de new y delete del ejemplo es totalmente inutil y tambien aplica el comentario de cabeza_nispero al respecto. new y delete son utiles desde el momento en que nos encontramos con la POO y estos operadores se encargan de llamar a constructores y destructores, para reservar y liberar memoria de una cadena de caracteres solo logran 'overhead'.

[cabeza_nispero]

Iniciado por blackwind

Estoy en desacuerdo. Porque el post se trata de actualizarte de C a C++ , no de C a otro lenguaje orientado a objetos como Java o C#, asi que eso si es muy importante.
Ademas, si vas a hacer una funcion pequeña, estoy seguro que el ojo humano no puede notar la diferencia de si usaste puts() o std::cout......

Saludos,

Es que "actualizarse" de C a C++... Recordemos que C es un subconjunto de C++. Simplemente estás aprendiendo más cosas, no aprendiendo otro lenguaje de cero.

Mi punto era que una función en C sencilla, convertirla a C++, no hace falta, primero porque en C++ existe la librería estándar de C, segundo que es más rápida, y tercero y sin discusión: Como hemos dicho, C++ es añadir cosas a C. Por lógica, si tienes una función C, y la quieres "portar" a C++, ¿qué sentido tiene? ¡Si C ya lo hace y C++ es más que un C con miles de cosas añadidas! Es como portar algo al mismo lenguaje pero complicándolo...

Para aprender, bien. Pero también hay que enseñar dónde C++ es útil, no sólo en funciones estructuradas de-las-de-toda-la-vida, porque eso ya lo hace C y C++ mismo... Diría la gente, "entonces, ¿qué diferencia hay entre C y C++ si hacen lo mismo?"

Espero que haya aclarado lo que quería decir.

[argentinator]

Los lenguajes de programacion son, segun creo, como cajas de herramientas para construir un software.

Me parece que defender un lenguaje o hacer apología de él no contribuye a nada. Pienso que son mas interesantes las deas en abstracto alrededor del diseño de software.

Ha habido una evolución de los lenguajes reflejando la necesidad de los programadores de llevar con más rapidez su intuición y sus ideas a la computadora, y manejando las nuevas teconologias (tanto micros como perifericos) que aparecen en el mundo.

Me gustaria mas una discusion sobre las ventajas de la POO a la hora de hacer aplicaciones, con ejemplos de diverso tipo. La sobrecarga, la herencia y el polimorfismo analizandolo en diversos tipos de aplicaciones.

Mudarse de C a C++ es mudarse de una caja de herramientas básica a una con más sofisticaciones, pero tambien a una nueva filosofia de programacion. Estaría bueno plantearse el progreso a nuevas filosofias, que mejoren lo que hoy tenemos.

Como sea, me parece que lo relevante es la mudanza de la programacion estructurada a la POO y no el paso de de C a C++.

[X.Cyclop]

Iniciado por argentinator

Me gustaria mas una discusion sobre las ventajas de la POO a la hora de hacer aplicaciones, con ejemplos de diverso tipo. La sobrecarga, la herencia y el polimorfismo analizandolo en diversos tipos de aplicaciones.

Espero lo mismo...

Iniciado por argentinator

Como sea, me parece que lo relevante es la mudanza de la programacion estructurada a la POO y no el paso de de C a C++.

Los 2 lenguajes son buenos. Mientras estés en bajo nivel todo va a estar bien, si te vas por el alto nivel ya te fregaste.

[blackwind]

Iniciado por cabeza_nispero

Para aprender, bien. Pero también hay que enseñar dónde C++ es útil, no sólo en funciones estructuradas de-las-de-toda-la-vida, porque eso ya lo hace C y C++ mismo... Diría la gente, "entonces, ¿qué diferencia hay entre C y C++ si hacen lo mismo?"

Espero que haya aclarado lo que quería decir.

Ok, punto entendido jeje.

Pero sigo con la otra duda:
que es "yo lo flipo"?

P.D: Estaria buena la discusion de la POO sobre la estructurada

saludos,