texto con palabras separadas en una sola linea:

cout <<"hola(espacio)" <<"weon(espacio)";

-----------------------------------------------------------------------------------
-----------------------
espacio en blaco entre lineas: \n\n

cout <<"hello\n\n";
cout <<"friend";
-----------------------------------------------------------------------------------
---------------------------------
// <--- los dos slash son comentarios, al ponerlos el programa no lo lee, son de
ayuda

cout<<" feo kl" //esta wea por ejemplo

-----------------------------------------------------------------------------------
-------------------------------
( /* ---> */ ) si quieres escribir un comentario con mas lineas se empiza con /* y
termina en */

/* esto es un ejemplo
de lo que hablo */
-----------------------------------------------------------------------------------
------------------------------

sumas basica: se usa"int" para definir un entero, se tiene que identificar dandole
un valor y un nombre eje: myvariabel, variable( la suman no va en comilla"")

#include <iostream>
using namespace std;

int main() {

int myvariable = 20 + 80; "myvariable" es

el nombre qeu le di al entero
cout << myvariable; // resulta 100
-----------------------------------------------------------------------------------
---------------------------------------
operadores relacionales:

>= mayor o igual que 7>=4 verdadero

<= menor o igual que 7<=4 falso

== igual a 7==4 falso

!= no igual a 7!=4 verdadero

return 0;
}
-----------------------------------------------------------------------------------
-----------------------------

int a;
int b= 42;
int a= 23; a y b son el nombre de
la variables
int sum = a +b;
cout<<sum;
return 0;
-----------------------------------------------------------------------------------
----------------------------------------------
es posble cambiar o asignarle el valor a una variable despues de ser declarada
{
int a;
int b= 42;
a= 23; <----------- le doy el valor despues
b=2; <----------- le cambio el valor despues
int sum = a +b;
cout<<sum;
return 0;
}

-----------------------------------------------------------------------------------
---------------------------------------------------
Cin: Permite al usario ingresar un valor( operador de extracion)(>>) una variable
almacena la data extraida

ejemplo que solcita al usario que ingrese un numero y lo almacena en la variable

"a"

{
int a;
cout<<"enter a number";
cin>> a;
return 0;
}

-----------------------------------------------------------------------------------
-----------------------------------------
multiplicacion: int x= 30*2;
division:int x= 60/2;
Suma:int x= 30+20;
Resta:int x= 50-20;

cout<<x;

-----------------------------------------------------------------------------------
---------------------------------------------
precedencia de operadores

1-T�rminos entre par�ntesis.

2-Potenciaci�n y ra�ces.
3-Multiplicaci�n y divisi�n.
4-Suma y resta.
-----------------------------------------------------------------------------------
---------
int x= 10;
cout<<x; <----------------------- sin comillas se mostrara el valor de x
en pantalla

cout<<"x"; <-------------------- con comillas se mostrara la letra

-----------------------------------------------------------------------------------
----------------------------
endl <--------------- crea un salto de linea tambien \n cout<<"hello
world \n"; \n\n <----- crea una linea en blanco

cout<<"hello world" << endl;

cout<<" seriously";
-----------------------------------------------------------------------------------
-------------
operadores de aginacion = asigna lo que del lado derecho al lado izquierdo
x+=4; <------ x= x+4
x-=3; <----- x= x-3

incremento: int x = 22;

x++ = 23

decremento: int x= 22; x--

-----------------------------------------------------------------------------------
--------------------------------
LAS DELCLARACIONES IF/ELSE, UNA SOLA DECLARACIOON PUEDE SER INCLUIDA SIN
DELIMITARLA DENTRO DE LAS LLAVES

int a= 10;
if(a>4)
cout<<"yes";
else
cout<<"no";
-----------------------------------------------------------------------------------
--------------------------------------
un bucle ejecuta repetidamente un conjunto de declaraciones hasta que una codicion
en particular sea satifecha

"While" ejecutara repteidamente una declaracion objetivo mientras que una condicion
dad permanezca verdadera

el bucle se repite mientras la condicon sea verdadera

cuando la declaracion se vielve falsa, el control sobre el programa es cambiado a

la linea que sigue inmediatamente despues del ciclo

while(condicion){
}
-----------------------------------------------------------------------------------
----------------------------------------
BUCLE FOR:

el bucle for nos permite escribir un codigo mas eficientemente, el bucle se

ejecutara un numero especifico de veces

for(int x=0; x<10;x++){

cout<<x<<endl;
}
-----------------------------------------------------------------------------------
--------------------------------------
declaracion switch:

valida una variable contra una lista de valores, los cuales son llamados cases,para
determinar si es igual a alguno de ellos

switch(expresion){
case value1:
declaracion(s);
break;
...
case valueN:
declaracion(s);
break;
}

la declaracion switch evalua la expresion para determinar si es igual al valor en

la declaracion del case.Si se ecuentra una coicidencia
, se ejecutan las declaraciones en ese case.

el case default: puede ser ultilzado para ejecutar una tarea cuando ninguno de los
cases resulta ser verdadero.

Declaracion Break: detiene la declaracion switch, en caso en que la variable es

igual a un case, las declaraiones que vienen despues del case continuaran
ejecutandose
hasta que se encuentre una declaracion break.En otras palabras, omitir una
declaracion break resulta en la ejecucion de todas la declaracoones en los
siguientes case, incluso aquellas que no
coinciden con la expresion.

int edad=42;
switch(edad){
case 16:
cout<<"muy joven" <<endl; se mostrara en pantalla:
case 42:
cout<<"adulto" <<endl; adulto-mayor-este es el case
default
case 70:
cout<<"mayor" <<endl;
default:
cout<<" este es el case default"<<endl;

el programa ejecuta las delclaraciones del case que coincide con la expresion,
imprimiendo "adulto" en la pantalla.
al no haber especificado una declaracion break, las declaraciones continuan
ejecuandose despues del case coincidente.
Asi todas las otras son impresas, este tipo de comportamineto es llamado
fallthrough.
-----------------------------------------------------------------------------------
-----------------------------------------

operadores logicos:

operador nombre del operador forma

&& operador AND y&&y

|| operador OR x||y
! operador NOT !x

AND funciona asi:

operador(expersion)izquierdo operador(expresion)derecho resultado

false false false
false true false
true false false
true true true

Operador OR|| retorna true(verdadero) si alguno de sus operandos es true(verdadero)

op izq op der resultado
falso falso falso
falso verdadero verdadero
veradero falso verdadero
verdadero verdadero verdadero

-----------------------------------------------------------------------------------
--------------------------------------------
arreglo:

es utilzado par almacenar una coleccion de data, es decir una coleccion de

variables.
en lugar de declarar multiples variables y almacenar valores individuales, puedes
alamcenar todas las variables en un solo arreglo para almacenar variables
cuando se declare un arreglo especifica el tipo, asi como el numero de elementos
que contendra.

int a[5]; la varaible "a" fue declarada como un arreglo de cinco valores
entreos[especificado en los corchetes] puedes iniciar un arreglo especificando los
valores que se almacenaran:

int a[5]= {11,45,62,70,88}; <---valores almacenados{}

los valores de las llaves no deben exceder el numero de elementos declarados[5]

-----------------------------------------------------------------------------------
-------------------------------------------------------
Arreglos multidimensionales:

pueden contener un numero ilimitado de dimensiones

string threeD[42][8][3];
-----------------------------------------------------------------------------------
-------------------------------------------
punteros:
o
cada vriable es una ubicacion en memoria, que tiene su direccion definida.

esa direccion puede ser accedida utilizando el operador &(tambien llamado el

operador "direccion de"), el cual inidica una direccion en memoria

por eje:

int score=5;
cout<<&score<<endl;
-----------------------------------------------------------------------------------
---------------------------------------------------------------
memoria dinamica:

el stack: todas tus variables locales toman la memoria del stack.

el heap: memoria del programa no utilizada que puede ser usada cuando el programa
es ejecutado para asignar dinamicamente la memoria.

muchas veces, no estas consciente con anticipacion de cuanta memoria necesitaras

para registrar una informacion en particular en una variable definida y
el tama�o requerido en memoria puede ser determinado en tiempo de ejecucion.

puedes asignar memoria dentro del heap en tiempo de ejecucion para la variable de
un tipo dado utilizando el operador "new", el cual retorna la direccion del espacio
asignado.

new int;

Una constante es un dato cuyo valor no puede cambiar durante la ejecuci�n del
programa. Recibe un valor en el momento de la compilaci�n y este permanece
inalterado durante todo el programa.

Una variable es un nombre asociado a un elemento de datos que est� situado en

posiciones contiguas de la memoria principal, y su valor puede cambiar durante la
ejecuci�n de un programa.

en matem�ticas llamamos constante a una magnitud que no cambia con el paso del
tiempo. En ocasiones, se puede tratar de un valor fijo y determinado.

Por otro lado, tenemos el concepto de variable, que se utiliza para definir toda
cantidad susceptible de tomar distintos valores num�ricos.
-----------------------------------------------------------------------------------
-------------------------------------------------------
puntero:

int *ptr <---- la variable ptr es un puntero a int

int score = 5;
int *scorePtr;
scorePtr=&score;

cout<< scorePtr <<endl;

se declara un puntero llamado "scorePtr" y se le asigna la direccion de memoria de

la variable anterir "score" usando"&"(direccion de)

ahora el valor de "scorePtr" es la direccion de memoria de "score".

-----------------------------------------------------------------------------------
--------------------------------------------------
memoria dinamica:

la memoria se divide en:

El stack: todas tus variables locales toman la memoria del stack

El heap: memoria del progrma no utilzada que puede ser usada cuando el programa es
ejecutado para asignar dinamicamente la memoria.

se puede almacenar memoria dentro del "heap" en tiempo de ejecucion para la

variable de un tipo dado utilizando el operador "new", el cual retorna la direccion
del espacio asignado
-----------------------------------------------------------------------------------
-------------------------------------------------------
la memoria asignada puede ser registrada en un puntero, el cual puede ser
desreferenciado para acceder la variable

int *p= new int;

*p=5;
hemos asignado memoriade forma dinamica para un entero(le pusimos otro valor) le
asignamos el valor de 5.

el puntero p (*p) esta almacenado en el stack como una variable local y mantiene
como valor la direccion del heap asignada.
El valor de 5 esta almacenado en esa direccion en el "heap".
-----------------------------------------------------------------------------------
-----------------------------------------------------

parametro:

return*2 <------ retorna un valor multiplacado por dos

---------------------------------------------------------------
numeros aleatorios:

se usa la libreria <cstdlib>

rand()
srand()