Nugeta clave de esta larga respuesta: comience con C normal y realice muchas iteraciones pequeñas para aprender explorando y buscando en Google, una vez que se sienta cómodo con los punteros, la administración de memoria y los tipos fuertes, pase a C ++ con objetos.
Comencé con Lua mucho antes de aprender C ++, pero aprendí C ++ en una clase universitaria con un instructor absolutamente fantástico. Sin un ambiente en el aula, saber JavaScript y Lua incluso podrían dificultar el aprendizaje de C ++.
Estas son algunas de las diferencias clave entre C ++ y Lua (estoy menos familiarizado con JavaScript). Si está familiarizado con las diferencias, siga adelante y omita esta lista.
- C ++ está fuertemente tipado. Cada vez que cree un elemento o variable, deberá decir exactamente qué es. Si parece que es mucho trabajo, recuerde que la otra cara es que siempre sabe qué es todo . Nunca tengo que preguntar “¿mi función obtendría una cadena como parámetro en lugar de una conexión de base de datos?” porque el compilador no le permitirá iniciar su programa de eventos si se pasa algo incorrecto. Por el contrario, JavaScript y Lua se escriben dinámicamente, lo que significa que nunca tiene que especificar qué va a ser una variable, pero nunca puede garantizar qué será una variable.
- Hablando de compiladores, Lua y JavaScript son lenguajes interpretados, donde C ++ es un lenguaje compilado. Un lenguaje interpretado es leído por otro programa en lugar de ser leído por su computadora. Un lenguaje compilado (y nativo) como C ++ se ejecuta directamente en el hardware de su computadora. En el caso de Roblox, un programa popular que usa Lua, los scripts de Lua en realidad están siendo ejecutados por un motor C ++.
- Lua y JavaScript tienen su memoria administrada por el programa que los ejecuta. Si creas una variable y luego la olvidas, el programa puede averiguar cuándo ya no se necesita y eliminarla. Por el contrario, C ++ es un lenguaje no administrado. Si crea una variable en C ++ y luego la olvida, permanecerá en la memoria de su computadora hasta que su programa se cierre. Crear cosas y luego no eliminarlas es una fuente de un problema común llamado pérdida de memoria.
- Lua y JavaScript son lenguajes abstractos de muy alto nivel. En C ++ tienes acceso casi directo a la memoria de tu computadora. Cuando dice la palabra “nuevo” en un programa de C ++, se le otorga una parte de la memoria RAM de su computadora. Entonces, usted es responsable de poner las cosas en esa memoria y luego eliminarlas cuando haya terminado con ellas. Puede acceder a esas ubicaciones en la memoria directamente usando direcciones de memoria denominadas “punteros”. En C ++ es importante comprender la diferencia entre la pila y el montón.
- C ++ está orientado a objetos. Así es JavaScript, Lua no lo es. (Aunque puede imitar la orientación a objetos en Lua usando tablas). En C ++, define sus clases en archivos “.h” y luego completa su implementación en archivos “.cpp”.
Ahora para aprender sobre C ++. C ++ es una extensión de un lenguaje antiguo llamado C. Java (no JavaScript, no están relacionados), C # y C ++ son todos “lenguajes de la familia C” que heredan su sintaxis de C. C ++ es el “más parecido a C” de esta familia de lenguajes y si escribe un programa en C ++ que no use la orientación a objetos o las bibliotecas de C ++, los compiladores de C puro deberían poder compilar su aplicación.
- Cómo hacer que RR.HH. se asegure de que los mentores de mi organización se encuentren con sus mentoreados y no se salten la tutoría
- ¿Cuál es la mejor plataforma para aprender R?
- ¿Cómo debo estructurar mi hábito de aprendizaje en línea (artículos y MOOC) sin abrumarme?
- Cómo aprender a hacer video anime.
- ¿Todos han apagado el televisor y encendido Quora para aprender?
Recomendaría aprender C ++, primero familiarizándome con los conceptos de C y luego agregando detalles de C ++ a su conocimiento más adelante.
Lo primero que necesitará en su camino hacia el aprendizaje de C es un entorno de compilación. Necesitarás varios programas.
Editor de texto: le ayuda a escribir el texto del programa
Ejemplo de opciones: Código VS, Bloc de notas, Notepad ++, Atom
Compilador: convierte su código C o C ++ legible por humanos en programas legibles por máquina.
Opciones de ejemplo: GCC, MinGw, Visual Studio
Si tiene una máquina Linux, ya debería tener instalado el editor de texto vim y el compilador gcc. También deberías poder obtener gcc fácilmente en mac. En Windows puede optar al bash en ubuntu en windows beta y usar gcc en windows.
El proceso de aprendizaje puede parecer algo como esto
- Cree un programa básico de C y almacénelo en un archivo llamado “helloworld.c”.
#include
void main (int argc, char ** args)
{
printf (“Hola Mundo \ n”);
}
~ $ gcc -o helloworld.c helloworld
2. Compilar el programa. Con GCC que se puede hacer con el comando.
~ $ gcc -o helloworld.c helloworld
3. Ejecute el programa ejecutándolo desde el terminal o abriéndolo desde su explorador de archivos.
~ $ ./helloworld
Hola Mundo
4. Haz un pequeño cambio al programa.
#include
void main (int argc, char ** args)
{
// Esto no funcionará pero alguien nuevo en C no lo sabría.
printf (argc);
}
5. Compila el programa y ejecútalo. Si funciona, vaya al paso 4. De lo contrario, continúe.
6. Repita: busque el problema en Google y experimente con los cambios hasta que haga algo genial.
#include
void main (int argc, char ** args)
{
// Una solución estilo Lua que no funcionará en C
printf (tostring (argc));
}
7. Eso no funciona, así que es hora de probar algo más.
#include
void main (int argc, char ** args)
{
// Solución de estilo AC descubierta usando google y encontrando esto
// https://www.codingunit.com/printf-format-specifiers-format-conversions-and-formatted-output
printf (“% d \ n”, argc);
}
8. Vaya al paso 4.
Aquí hay un código de ejemplo para ayudarlo a “arrancar” en el mundo de C y C ++.
Incluirá un ejemplo simple de muchas características diferentes de C. Puede usarlo para experimentar y comenzar a aprender sobre el mundo de la programación nativa, fuertemente tipada y sin restricciones.
// Esta línea incluye el archivo de cabecera “Salida de entrada estándar” (biblioteca)
#include
// Esta línea declara la “firma” de una función de fibonacci.
int fib (int n);
// Los programas en C se leen “en orden”, por lo que debemos advertir al compilador
// que esa función realmente existe, solo decimos lo que hace más tarde.
// Eso se llama “Declaración hacia adelante”.
// Una estructura es una colección de datos. Podemos “crear” muchos stack_elements.
// Cada stack_element tendrá su propio “valor” y “siguiente”.
// ¡Note que “siguiente” es lo mismo que está almacenado en!
struct stack_element
{
char * valor;
struct stack_element * next;
};
// Una pila es como, bueno, pila.
// Cuando pones algo en la parte superior no puedes llegar a lo que está debajo.
// Pero es súper fácil “empujar” las cosas en la parte superior y “quitarlas”.
estructura de la pila
{
cuenta int
struct stack_element * top;
};
// Esta función empujará algo en la parte superior de una pila.
void push (struct stack * s, char * data)
{
// Permite declarar una variable para almacenar un nuevo stack_element.
struct stack_element * newElement;
// Note el * después del tipo. Eso significa que “apunta” a la
// ubicación que realmente almacena el valor.
// newElement >>> no almacena <<< a stack_element !!
// Almacena una “dirección de correo” de tipo donde se encuentra un stack_element
// vivirá.
// Necesitaremos saber cuánta memoria utiliza un stack_element.
int bytes = sizeof (struct stack_element);
// malloc es una función que le pide a la computadora algo de memoria.
newElement = malloc (bytes);
// Ahora tenemos “memoria asignada (malloc)” un nuevo stack_element.
// Pongamos nuestros datos en ella.
newElement-> value = data;
// Note el operador -> usado para obtener un miembro de newElement.
// Tuvimos que hacer eso porque newElement es un >>> puntero << no un
// apilar elemento! Si tuviéramos una variable de stack_element real, no una
// dirección de uno, habríamos dicho newElement.value = data en su lugar.
// ¡Ahora vamos a poner nuestro stack_element en la pila!
// Lo haremos configurando el campo “siguiente” de newElement en
// la dirección del valor “superior” actual de la pila, y luego
// estableceremos la dirección almacenada en “top” en la dirección newElement.
newElement-> next = s-> top;
s-> top = newElement;
}
// Esta función quitará algo de la parte superior de una pila.
pop vacío (struct stack * s)
{
// Almacena la dirección superior en una variable de dirección “oldElement”
struct stack_element * oldElement = s-> top;
// Establece la parte superior de la pila en la parte superior anterior.
s-> top = oldElement-> next;
// Borra todo lo que está almacenado en la dirección “oldElement”
libre (oldElement);
}
// Esta función devuelve la dirección del valor superior en la pila.
char * peek (struct stack * s)
{
// si la pila está vacía, el valor será NULL (nil)
if (s-> top == NULL)
devuelve NULL;
devuelve s-> top-> valor;
}
// Esta es la función principal. Aquí es donde el programa comienza a ejecutarse.
int main (int argc, char ** argv)
{
// Imprime el primer argumento (el nombre del programa)
printf (“% s \ n”, argv [0]);
// Crear una nueva pila
struct stack * myStack = malloc (sizeof (struct stack));
// Empuje el resto de los argumentos de línea de comando en la pila
int i;
para (i = 1; i <argc; i ++)
{
push (myStack, argv [i]);
}
// Imprime todos los argumentos de la línea de comandos
// Mientras que c no es NULL
char * c;
mientras que (c = peek (myStack))
{
printf (“% s \ n”, c);
pop (myStack);
}
// Proporciona un separador visual entre las cosas de la pila y las cosas de fibonacci.
printf (“\ n ————- \ n \ n”);
// Imprime los primeros 11 (0 a 10) números de fibonacci
para (i = 0; i <11; i ++)
printf (“% d,% d \ n”, i, fib (i));
printf (“Esta declaración no está en el bucle for. \ n”);
// Eso es porque las operaciones de flujo (si, para, mientras ..)
// necesita llaves para más de 1 declaración
// Salir del programa con valor 1.
printf (“Programa completado \ n”);
devuelve 1;
}
// Esta función fue “declarada hacia adelante” al principio de este programa.
// Calcula el valor Nth de la secuencia de fibonacci.
int fib (int n)
{
si (n <= 1)
devuelve n;
retorno fib (n – 2) + fib (n – 1);
}
Para ejecutar el programa compílalo. Tu compilador puede darte advertencias acerca de las cosas de malloc, pero es de esperar que no te den errores.
Para compilar usando GCC desde una terminal, use el comando
~ $ gcc -o stack.c stack
(Suponiendo que haya nombrado su pila de archivos.c)
Luego, para ejecutar su programa, use un terminal o indicador de comando en Windows y vaya al directorio donde está almacenado su programa. Use el comando
~ $ ./stack Pancake1 Pancake2 Pancake3
Y debería obtener una salida que se parece a
./apilar
Panqueque3
Panqueque2
Panqueque1
————-
0, 0
1, 1
2, 1
3, 2
4, 3
5, 5
6, 8
7, 13
8, 21
9, 34
10, 55
Esta declaración no está en el bucle for.
Programa completado
¡Feliz codificación!