\documentclass[10pt,a4paper]{article}

% Packages
\usepackage{fancyhdr}           % For header and footer
\usepackage{multicol}           % Allows multicols in tables
\usepackage{tabularx}           % Intelligent column widths
\usepackage{tabulary}           % Used in header and footer
\usepackage{hhline}             % Border under tables
\usepackage{graphicx}           % For images
\usepackage{xcolor}             % For hex colours
%\usepackage[utf8x]{inputenc}    % For unicode character support
\usepackage[T1]{fontenc}        % Without this we get weird character replacements
\usepackage{colortbl}           % For coloured tables
\usepackage{setspace}           % For line height
\usepackage{lastpage}           % Needed for total page number
\usepackage{seqsplit}           % Splits long words.
%\usepackage{opensans}          % Can't make this work so far. Shame. Would be lovely.
\usepackage[normalem]{ulem}     % For underlining links
% Most of the following are not required for the majority
% of cheat sheets but are needed for some symbol support.
\usepackage{amsmath}            % Symbols
\usepackage{MnSymbol}           % Symbols
\usepackage{wasysym}            % Symbols
%\usepackage[english,german,french,spanish,italian]{babel}              % Languages

% Document Info
\author{dali\_orbaj}
\pdfinfo{
  /Title (c-programming.pdf)
  /Creator (Cheatography)
  /Author (dali\_orbaj)
  /Subject (C programming Cheat Sheet)
}

% Lengths and widths
\addtolength{\textwidth}{6cm}
\addtolength{\textheight}{-1cm}
\addtolength{\hoffset}{-3cm}
\addtolength{\voffset}{-2cm}
\setlength{\tabcolsep}{0.2cm} % Space between columns
\setlength{\headsep}{-12pt} % Reduce space between header and content
\setlength{\headheight}{85pt} % If less, LaTeX automatically increases it
\renewcommand{\footrulewidth}{0pt} % Remove footer line
\renewcommand{\headrulewidth}{0pt} % Remove header line
\renewcommand{\seqinsert}{\ifmmode\allowbreak\else\-\fi} % Hyphens in seqsplit
% This two commands together give roughly
% the right line height in the tables
\renewcommand{\arraystretch}{1.3}
\onehalfspacing

% Commands
\newcommand{\SetRowColor}[1]{\noalign{\gdef\RowColorName{#1}}\rowcolor{\RowColorName}} % Shortcut for row colour
\newcommand{\mymulticolumn}[3]{\multicolumn{#1}{>{\columncolor{\RowColorName}}#2}{#3}} % For coloured multi-cols
\newcolumntype{x}[1]{>{\raggedright}p{#1}} % New column types for ragged-right paragraph columns
\newcommand{\tn}{\tabularnewline} % Required as custom column type in use

% Font and Colours
\definecolor{HeadBackground}{HTML}{333333}
\definecolor{FootBackground}{HTML}{666666}
\definecolor{TextColor}{HTML}{333333}
\definecolor{DarkBackground}{HTML}{0789A3}
\definecolor{LightBackground}{HTML}{EFF7F9}
\renewcommand{\familydefault}{\sfdefault}
\color{TextColor}

% Header and Footer
\pagestyle{fancy}
\fancyhead{} % Set header to blank
\fancyfoot{} % Set footer to blank
\fancyhead[L]{
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{C}
    \SetRowColor{DarkBackground}
    \vspace{-7pt}
    {\parbox{\dimexpr\textwidth-2\fboxsep\relax}{\noindent
        \hspace*{-6pt}\includegraphics[width=5.8cm]{/web/www.cheatography.com/public/images/cheatography_logo.pdf}}
    }
\end{tabulary}
\columnbreak
\begin{tabulary}{11cm}{L}
    \vspace{-2pt}\large{\bf{\textcolor{DarkBackground}{\textrm{C programming Cheat Sheet}}}} \\
    \normalsize{by \textcolor{DarkBackground}{dali\_orbaj} via \textcolor{DarkBackground}{\uline{cheatography.com/202287/cs/42926/}}}
\end{tabulary}
\end{multicols}}

\fancyfoot[L]{ \footnotesize
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{LL}
  \SetRowColor{FootBackground}
  \mymulticolumn{2}{p{5.377cm}}{\bf\textcolor{white}{Cheatographer}}  \\
  \vspace{-2pt}dali\_orbaj \\
  \uline{cheatography.com/dali-orbaj} \\
  \end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Cheat Sheet}}  \\
   \vspace{-2pt}Published 7th August, 2024.\\
   Updated 22nd September, 2024.\\
   Page {\thepage} of \pageref{LastPage}.
\end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Sponsor}}  \\
  \SetRowColor{white}
  \vspace{-5pt}
  %\includegraphics[width=48px,height=48px]{dave.jpeg}
  Measure your website readability!\\
  www.readability-score.com
\end{tabulary}
\end{multicols}}




\begin{document}
\raggedright
\raggedcolumns

% Set font size to small. Switch to any value
% from this page to resize cheat sheet text:
% www.emerson.emory.edu/services/latex/latex_169.html
\footnotesize % Small font.

\begin{multicols*}{2}

\begin{tabularx}{8.4cm}{p{0.76 cm} x{3.268 cm} x{3.572 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{3}{x{8.4cm}}{\bf\textcolor{white}{Bloques}}  \tn
% Row 0
\SetRowColor{LightBackground}
\seqsplit{switch} & switch(argumento)\{case x: (...);break;default:break;\} & El argumento es una expresion entera y los cases deben ser diferentes. El default es opcional \tn 
% Row Count 6 (+ 6)
% Row 1
\SetRowColor{white}
for & for (init;cond;post) & Es equivalente a: init; while(cond)\{(...)post;\} \tn 
% Row Count 9 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}---}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{p{0.8 cm} x{7.2 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Parametros para printf()}}  \tn
% Row 0
\SetRowColor{LightBackground}
\%d/i & int \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
\%f & double (usando punto decimal) \tn 
% Row Count 2 (+ 1)
% Row 2
\SetRowColor{LightBackground}
\%x & hexadecimales (int sin signo en base 10) \tn 
% Row Count 4 (+ 2)
% Row 3
\SetRowColor{white}
\%o & octales (int sin signo ni cero inicial en base 10) \tn 
% Row Count 6 (+ 2)
% Row 4
\SetRowColor{LightBackground}
\%u & int sin signo en base 10 \tn 
% Row Count 7 (+ 1)
% Row 5
\SetRowColor{white}
\%c & Muestra el caracter que simboliza un int \tn 
% Row Count 9 (+ 2)
% Row 6
\SetRowColor{LightBackground}
\%s & Cadena de caracteres \tn 
% Row Count 10 (+ 1)
% Row 7
\SetRowColor{white}
\%e & double (decimal en notacion exponencial) \tn 
% Row Count 12 (+ 2)
% Row 8
\SetRowColor{LightBackground}
\%g & double (decimal con la notacion que requiera menor espacio) \tn 
% Row Count 14 (+ 2)
% Row 9
\SetRowColor{white}
\%\% & imprime \% \tn 
% Row Count 15 (+ 1)
% Row 10
\SetRowColor{LightBackground}
\%p & direccion de memoria (puntero) \tn 
% Row Count 16 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{1.44 cm} x{6.56 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Entrada y salida de datos}}  \tn
% Row 0
\SetRowColor{LightBackground}
\seqsplit{printf()} & Imprime por pantalla \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
\seqsplit{scanf()} & Lee datos y los guarda en la variable proporcionada como argumento \tn 
% Row Count 5 (+ 3)
% Row 2
\SetRowColor{LightBackground}
\seqsplit{getchar()} & Lee cadenas de caracteres uno a uno \tn 
% Row Count 7 (+ 2)
% Row 3
\SetRowColor{white}
\seqsplit{putchar()} & Imprime un caracter por pantalla \tn 
% Row Count 9 (+ 2)
% Row 4
\SetRowColor{LightBackground}
gets() & Lee una linea de stdin (hasta \textbackslash{}n) y la guarda en el buffer \tn 
% Row Count 11 (+ 2)
% Row 5
\SetRowColor{white}
puts() & Imprime una cadena con un \textbackslash{}n al final \tn 
% Row Count 13 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{2.72 cm} x{5.28 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{static}}  \tn
% Row 0
\SetRowColor{LightBackground}
Dentro de una funcion & No pierde su valor entre invocación e invocación. \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
Fuera de una función & Visible nomas en el entorno donde está definida, compartida en ese .c. \tn 
% Row Count 5 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{2.72 cm} x{5.28 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{extern}}  \tn
% Row 0
\SetRowColor{LightBackground}
Dentro de una funcion & Solo esa función va a poder acceder a la variable. \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
Fuera de una funcion & Visible desde todos los archivos del programa. \tn 
% Row Count 4 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{(!) Para declarar (no definir) el uso de una variable que es de otro código.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{1.84 cm} x{6.16 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Punteros}}  \tn
% Row 0
\SetRowColor{LightBackground}
\seqsplit{Definicion} & tipoApuntado * nombrePuntero; \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
\seqsplit{Parametro} & tipo nombreFunc (tipo * nombreParam, ... ); \tn 
% Row Count 4 (+ 2)
% Row 2
\SetRowColor{LightBackground}
\seqsplit{Invocacion} & nombreFunc(\&variable); \tn 
% Row Count 6 (+ 2)
% Row 3
\SetRowColor{white}
 & \seqsplit{nombreFunc(variablePunt);} \tn 
% Row Count 7 (+ 1)
% Row 4
\SetRowColor{LightBackground}
\seqsplit{Equivalentes} & arreglo \textless{}-{}-\textgreater{} \&arreglo{[}0{]} \tn 
% Row Count 9 (+ 2)
% Row 5
\SetRowColor{white}
 & *arreglo \textless{}-{}-\textgreater{} arreglo{[}0{]} \tn 
% Row Count 10 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{\textless{}string.h\textgreater{}}}  \tn
% Row 0
\SetRowColor{LightBackground}
unsigned int strlen(const char * s); & Recorre el vector y devuelve la longitud sin contar el 0 final. \tn 
% Row Count 4 (+ 4)
% Row 1
\SetRowColor{white}
char * strcpy(char * t, const char * s); & Copia todos los caracteres de source a target. Asume que hay suficiente lugar y que source es null terminated. Devuelve un puntero a la cadena target (la direccion donde copio). \tn 
% Row Count 13 (+ 9)
% Row 2
\SetRowColor{LightBackground}
char * strncpy(char * t, const char * s, int n); & Copia hasta n caracteres y no pone el cero final si n es menor a la cantidad de caracteres que tiene que copiar. Si N es mayor copia todo y completa con ceros hasta llegar a N caracteres. Retorna una copia de target. \tn 
% Row Count 24 (+ 11)
% Row 3
\SetRowColor{white}
char * strcat(char * t, const char * s); & Concatena, agrega source al final de target \tn 
% Row Count 27 (+ 3)
% Row 4
\SetRowColor{LightBackground}
char * strncat(char * t, const char * s, int n); & Concatenar hasta n caracteres. Agrega como máximo n caracteres de la matriz de caracteres apuntada por s, deteniéndose si se encuentra el carácter nulo, al final de la cadena de bytes null terminated apuntada por target. El carácter s{[}0{]} reemplaza al cero al final de target. El carácter nulo de terminación siempre se agrega al final (por lo que el número máximo de bytes que la función puede escribir es n + 1). \tn 
% Row Count 49 (+ 22)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{\textless{}string.h\textgreater{} (cont)}}  \tn
% Row 5
\SetRowColor{LightBackground}
int strcmp( const char * t, const char * s ); & Compara los valores ASCII de 2 cadenas de bytes null-terminated haciendo t-s \tn 
% Row Count 4 (+ 4)
% Row 6
\SetRowColor{white}
 & -Valor negativo si t aparece antes que s. -Cero si t y s son iguales. -Valor positivo si aparece t después que s en la tabla ascii. \tn 
% Row Count 11 (+ 7)
% Row 7
\SetRowColor{LightBackground}
int strncmp(const char * t, const char * s, int n); & Compara los valores ascii de t y s pero hasta N caracteres. \tn 
% Row Count 14 (+ 3)
% Row 8
\SetRowColor{white}
char * strchr(const char * s, char c); & Devuelve la dirección de memoria de la primera aparición del carácter c. Si no aparece devuelve null. El carácter de terminación se considera parte de la cadena y se puede encontrar al buscar '\textbackslash{} 0'. \tn 
% Row Count 25 (+ 11)
% Row 9
\SetRowColor{LightBackground}
char * strrchr(const char * s, char c); & Lo mismo pero empezando por la derecha. \tn 
% Row Count 28 (+ 3)
% Row 10
\SetRowColor{white}
char * strstr(const char * t, const char * s); & Devuelve, si el string s está contenido en t, la dirección del primer carácter de s en t. \tn 
% Row Count 33 (+ 5)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{\textless{}string.h\textgreater{} (cont)}}  \tn
% Row 11
\SetRowColor{LightBackground}
char * strpbrk(const char * s, const char * set); & Busca la primera aparición de alguno de los caracteres, el primero que aparezca. \tn 
% Row Count 5 (+ 5)
% Row 12
\SetRowColor{white}
int strcasecmp (const char *, const char *); & Compara 2 caracteres pero a diferencia de strcmp, ignora minusculas y mayusculas, entonces si pongo a y A devuelve que son iguales. \tn 
% Row Count 12 (+ 7)
% Row 13
\SetRowColor{LightBackground}
int strncasecmp (const char *, const char *, size\_t); & Lo mismo pero hasta N caracteres. \tn 
% Row Count 15 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{1.2 cm} x{6.8 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Vectores}}  \tn
% Row 0
\SetRowColor{LightBackground}
\seqsplit{Arreglo} & tipo nombreAreglo {[}dimension{]} = \{valor0, valor1, valor2, …\}. De tipo int por default. \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
 & Parametro/prototipo: const/- tipo nombreVector{[}{]}. Argumento: nombreVector. \tn 
% Row Count 6 (+ 3)
% Row 2
\SetRowColor{LightBackground}
\seqsplit{Matriz} & tipo nombreMatriz{[}filas{]}{[}cols{]}=\{\{valor 0, valor1, ...\}, \{valor0, valor1, ...\}, ...\}. \tn 
% Row Count 9 (+ 3)
% Row 3
\SetRowColor{white}
 & Parametro/prototipo: const/- tipo nombreMatriz{[}{]}{[}COLS{]}. Argumento: nombreMatriz. \tn 
% Row Count 12 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{1.36 cm} x{6.64 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Constantes simbolicas predefinidas}}  \tn
% Row 0
\SetRowColor{LightBackground}
\seqsplit{\_\_LINE\_\_} & Constante decimal con el nro. de la linea actual \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
\seqsplit{\_\_FILE\_\_} & String que contiene el nombre del archivo que se esta compilando \tn 
% Row Count 4 (+ 2)
% Row 2
\SetRowColor{LightBackground}
\seqsplit{\_\_DATE\_\_} & String con la fecha de compilación \tn 
% Row Count 6 (+ 2)
% Row 3
\SetRowColor{white}
\seqsplit{\_\_TIME\_\_} & String con la hora de compilación \tn 
% Row Count 8 (+ 2)
% Row 4
\SetRowColor{LightBackground}
\seqsplit{\_\_func\_\_} & String con el nombre de la funcion \tn 
% Row Count 10 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{3.52 cm} x{4.48 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{\textless{}math.h\textgreater{}}}  \tn
% Row 0
\SetRowColor{LightBackground}
double fabs(double x); & valor absoluto de x \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
double floor(double x); & entero más grande menor o igual a x \tn 
% Row Count 4 (+ 2)
% Row 2
\SetRowColor{LightBackground}
double ceil(double x); & valor entero más pequeño mayor o igual a x \tn 
% Row Count 6 (+ 2)
% Row 3
\SetRowColor{white}
double fmod(double x,double y); & resto de x dividido por y \tn 
% Row Count 8 (+ 2)
% Row 4
\SetRowColor{LightBackground}
double sqrt(double x); & raíz cuadrada de x \tn 
% Row Count 10 (+ 2)
% Row 5
\SetRowColor{white}
double pow(double x,double y); & x a la y \tn 
% Row Count 12 (+ 2)
% Row 6
\SetRowColor{LightBackground}
double exp(double x); & e a la x \tn 
% Row Count 14 (+ 2)
% Row 7
\SetRowColor{white}
double log(double x); & logaritmo natural (en base e) de x \tn 
% Row Count 16 (+ 2)
% Row 8
\SetRowColor{LightBackground}
double log10(double x); & logaritmo en base 10 de x \tn 
% Row Count 18 (+ 2)
% Row 9
\SetRowColor{white}
double sin(double radians); & sin \tn 
% Row Count 20 (+ 2)
% Row 10
\SetRowColor{LightBackground}
double cos(double radians); & cos \tn 
% Row Count 22 (+ 2)
% Row 11
\SetRowColor{white}
double tan(double radians); & tan \tn 
% Row Count 24 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{2.64 cm} x{5.36 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{\textless{}ctype.h\textgreater{}}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{int islower(int c);} \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{int isupper(int c);} \tn 
% Row Count 2 (+ 1)
% Row 2
\SetRowColor{LightBackground}
int isalpha(int c); & es letra \tn 
% Row Count 4 (+ 2)
% Row 3
\SetRowColor{white}
int isdigit(int c); & de 0 a 9 \tn 
% Row Count 6 (+ 2)
% Row 4
\SetRowColor{LightBackground}
int isxdigit(int c); & es digito hexadecimal \tn 
% Row Count 8 (+ 2)
% Row 5
\SetRowColor{white}
int isalnum(int c); & es digito o letra \tn 
% Row Count 10 (+ 2)
% Row 6
\SetRowColor{LightBackground}
int isprint(int c); & tiene representacion visual en tabla ascii. 0 si no se puede imprimir \tn 
% Row Count 13 (+ 3)
% Row 7
\SetRowColor{white}
int ispunct(int c); & !"\#\$\%\&'()*+,-./:;\textless{}=\textgreater{}?@{[}\textbackslash{}{]}\textasciicircum{}\_`\{|\}\textasciitilde{} \tn 
% Row Count 15 (+ 2)
% Row 8
\SetRowColor{LightBackground}
int isspace(int c); & espacio, tabs, newline, etc \tn 
% Row Count 17 (+ 2)
% Row 9
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{int toupper(int c);} \tn 
% Row Count 18 (+ 1)
% Row 10
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{int tolower(int c);} \tn 
% Row Count 19 (+ 1)
% Row 11
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{int iscntrl (int c)} \tn 
% Row Count 20 (+ 1)
% Row 12
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{int isgraph (int c)} \tn 
% Row Count 21 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{(!) Devuelve 0 o un valor distinto de 0 \newline (!) Ninguno cambia el valor de la variable argumento}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{3.44 cm} x{4.56 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{\textless{}stdlib.h\textgreater{}}}  \tn
% Row 0
\SetRowColor{LightBackground}
int abs(int num); & Modulo \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
long labs(long num); & Módulo para long's \tn 
% Row Count 3 (+ 2)
% Row 2
\SetRowColor{LightBackground}
int rand(void); & Valor pseudo aleatorio, le paso time(NULL) \tn 
% Row Count 5 (+ 2)
% Row 3
\SetRowColor{white}
void srand(unsigned int seed); & Setea el valor de inicio de rand \tn 
% Row Count 7 (+ 2)
% Row 4
\SetRowColor{LightBackground}
exit(0) & lo mismo que return 0, nomas p/el main con un error irrecuperable \tn 
% Row Count 10 (+ 3)
% Row 5
\SetRowColor{white}
double atof(const char * s); & Devuelve lo que lee del string s en un double. \tn 
% Row Count 13 (+ 3)
% Row 6
\SetRowColor{LightBackground}
int atoi(const char * s); & Devuelve lo que lee del string s en un entero. No redondea. Y si es un numero mas grande de lo que puede representar, va a devolver cualquier cosa por el overflow. \tn 
% Row Count 21 (+ 8)
% Row 7
\SetRowColor{white}
long atol(const char * s); & Devuelve lo que lee del string s en un long. \tn 
% Row Count 23 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{\textless{}stdlib.h\textgreater{} - Memoria dinamica}}  \tn
% Row 0
\SetRowColor{LightBackground}
void * malloc(size\_t size); & Reserva memoria. Ejemplo: int *v = \seqsplit{malloc(20*sizeof(int))}.  La función malloc retorna en su nombre la dirección de una zona de memoria de size bytes reservada en forma dinámica, setea errno en ENOMEM si no hay memoria libre. \tn 
% Row Count 12 (+ 12)
% Row 1
\SetRowColor{white}
void * calloc(size\_t nobj, size\_t size); & Además de reservar la memoria inicializa el vector con ceros.  La función calloc retorna en su nombre la dirección de una zona de memoria de size x nobj bytes reservada en forma dinámica e inicializada en cero \tn 
% Row Count 23 (+ 11)
% Row 2
\SetRowColor{LightBackground}
void {\emph{ realloc(void }} p, size\_t size); & Función para pedir que agrande o achique el vector.  La función realloc modifica el tamaño de una zona de memoria previamente reservada que comienza en la dirección p \tn 
% Row Count 32 (+ 9)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{\textless{}stdlib.h\textgreater{} - Memoria dinamica (cont)}}  \tn
% Row 3
\SetRowColor{LightBackground}
void free(void * p); & La función free libera la zona de memoria previamente reservada que comienza en la dirección p \tn 
% Row Count 5 (+ 5)
% Row 4
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{typedef unsigned int size\_t;} \tn 
% Row Count 6 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{(!) void * significa que es un puntero de cualquier tipo, es decir un puntero genérico, se le puede asignar el valor de cualquier tipo de puntero y, asimismo, a un puntero de cualquier tipo se le puede asignar un puntero generico. Lo que no se puede hacer con un puntero generico es desreferenciarlo, ya que estaria determinando la cantidad de bytes que ocupa cada tipo de dato, para desreferenciar, antes habria que castear a algun tipo de puntero -{}-\textgreater{} * (int *) p;}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{p{1.6 cm} x{6.4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{\textless{}stdbool.h\textgreater{}}}  \tn
% Row 0
\SetRowColor{LightBackground}
bool & true=1 y false=0 \tn 
% Row Count 1 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{\textless{}stdio.h\textgreater{}}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{int getchar(void);} \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{int putchar(int c);} \tn 
% Row Count 2 (+ 1)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{int ungetc(int c, FILE * stream);} \tn 
% Row Count 3 (+ 1)
% Row 3
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{int printf(const char *fmt, ...);} \tn 
% Row Count 4 (+ 1)
% Row 4
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{int puts(const char *s);} \tn 
% Row Count 5 (+ 1)
% Row 5
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{void clearerr(FILE * stream);} \tn 
% Row Count 6 (+ 1)
% Row 6
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{int feof(FILE * stream);} \tn 
% Row Count 7 (+ 1)
% Row 7
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{int ferror(FILE * stream);} \tn 
% Row Count 8 (+ 1)
% Row 8
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{void perror(const char * s);} \tn 
% Row Count 9 (+ 1)
% Row 9
\SetRowColor{white}
int sprintf( char * s, const char * fmt, ...); & La única diferencia con printf es que en lugar de enviarlo a la salida estándar lo almacena en un string. \tn 
% Row Count 15 (+ 6)
% Row 10
\SetRowColor{LightBackground}
int sscanf( char * s, const char * fmt, ...); & En lugar de leer el texto de la entrada estándar lo toma del string. Y devuelve la cantidad de elementos que se asignaron correctamente. \tn 
% Row Count 22 (+ 7)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{(!) Todas estas funciones para string se encargan de poner un cero al final menos strncopy}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{6.32 cm} x{1.68 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Precedencia y asociatividad}}  \tn
% Row 0
\SetRowColor{LightBackground}
() {[}{]} . -\textgreater{} & Izq a der \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
! \textasciitilde{} ++ -{}- + \_ (tipo) sizeof & Der a izq \tn 
% Row Count 4 (+ 2)
% Row 2
\SetRowColor{LightBackground}
* / \% & Izq a der \tn 
% Row Count 6 (+ 2)
% Row 3
\SetRowColor{white}
+ - & Izq a der \tn 
% Row Count 8 (+ 2)
% Row 4
\SetRowColor{LightBackground}
\textless{}\textless{} \textgreater{}\textgreater{} & Izq a der \tn 
% Row Count 10 (+ 2)
% Row 5
\SetRowColor{white}
\textless{} \textless{}= \textgreater{} \textgreater{}= & Izq a der \tn 
% Row Count 12 (+ 2)
% Row 6
\SetRowColor{LightBackground}
== != & Izq a der \tn 
% Row Count 14 (+ 2)
% Row 7
\SetRowColor{white}
\& & Izq a der \tn 
% Row Count 16 (+ 2)
% Row 8
\SetRowColor{LightBackground}
\textasciicircum{} & Izq a der \tn 
% Row Count 18 (+ 2)
% Row 9
\SetRowColor{white}
| & Izq a der \tn 
% Row Count 20 (+ 2)
% Row 10
\SetRowColor{LightBackground}
\&\& & Izq a der \tn 
% Row Count 22 (+ 2)
% Row 11
\SetRowColor{white}
|| & Izq a der \tn 
% Row Count 24 (+ 2)
% Row 12
\SetRowColor{LightBackground}
?: & Der a izq \tn 
% Row Count 26 (+ 2)
% Row 13
\SetRowColor{white}
= += -= *= /= \%= \&= \textasciicircum{}= |= \textless{}\textless{}= \textgreater{}\textgreater{}= & Der a izq \tn 
% Row Count 28 (+ 2)
% Row 14
\SetRowColor{LightBackground}
, & Izq a der \tn 
% Row Count 30 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{(!) Los +, -, * unarios tienen mayor precedencia que las formas binarias}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{p{1.28 cm} x{6.72 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Operadores p/bits}}  \tn
% Row 0
\SetRowColor{LightBackground}
\textasciitilde{} & Complemento \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
\textasciicircum{} & Xor \tn 
% Row Count 2 (+ 1)
% Row 2
\SetRowColor{LightBackground}
\& & And \tn 
% Row Count 3 (+ 1)
% Row 3
\SetRowColor{white}
| & Or \tn 
% Row Count 4 (+ 1)
% Row 4
\SetRowColor{LightBackground}
\seqsplit{Sizeof} & \#bits que ocupa un tipo de dato \tn 
% Row Count 5 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4.56 cm} x{3.44 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Constantes}}  \tn
% Row 0
\SetRowColor{LightBackground}
Long & 123L/l \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
Unsigned & 123U/u \tn 
% Row Count 2 (+ 1)
% Row 2
\SetRowColor{LightBackground}
Unsigned long & 123UL/ul \tn 
% Row Count 3 (+ 1)
% Row 3
\SetRowColor{white}
Float & 12.3F/f \tn 
% Row Count 4 (+ 1)
% Row 4
\SetRowColor{LightBackground}
Double & 12.3 \tn 
% Row Count 5 (+ 1)
% Row 5
\SetRowColor{white}
Long double & 12.3L/l \tn 
% Row Count 6 (+ 1)
% Row 6
\SetRowColor{LightBackground}
Octales & Prefijo 0 \tn 
% Row Count 7 (+ 1)
% Row 7
\SetRowColor{white}
Hexadecimales & Prefijo 0x \tn 
% Row Count 8 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{2.204 cm} p{0.76 cm} x{4.636 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{3}{x{8.4cm}}{\bf\textcolor{white}{Datos}}  \tn
% Row 0
\SetRowColor{LightBackground}
char & 8 & -128 a 127 \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
unsigned char & 8 & 0 a 255 \tn 
% Row Count 3 (+ 2)
% Row 2
\SetRowColor{LightBackground}
signed char & 8 & -128 a 127 \tn 
% Row Count 4 (+ 1)
% Row 3
\SetRowColor{white}
short & 16 & -32768 a 32767 \tn 
% Row Count 5 (+ 1)
% Row 4
\SetRowColor{LightBackground}
int & 16 & -32768 a 32767 \tn 
% Row Count 6 (+ 1)
% Row 5
\SetRowColor{white}
unsigned int & 16 & 0 a 65535 \tn 
% Row Count 8 (+ 2)
% Row 6
\SetRowColor{LightBackground}
signed int & 16 & -32768 a 32767 \tn 
% Row Count 9 (+ 1)
% Row 7
\SetRowColor{white}
short int & 16 & -32768 a 32767 \tn 
% Row Count 10 (+ 1)
% Row 8
\SetRowColor{LightBackground}
unsigned short int & 16 & 0 a 65535 \tn 
% Row Count 12 (+ 2)
% Row 9
\SetRowColor{white}
signed short int & 16 & -32768 a 32767 \tn 
% Row Count 14 (+ 2)
% Row 10
\SetRowColor{LightBackground}
long int & 32 & -2147483648 a 2147483647 \tn 
% Row Count 15 (+ 1)
% Row 11
\SetRowColor{white}
signed long int & 32 & -2147483648 a 2147483647 \tn 
% Row Count 17 (+ 2)
% Row 12
\SetRowColor{LightBackground}
unsigned long int & 32 & 0 a 4294967295 \tn 
% Row Count 19 (+ 2)
% Row 13
\SetRowColor{white}
long & 32 & -2147483648 a 2147483647 \tn 
% Row Count 20 (+ 1)
% Row 14
\SetRowColor{LightBackground}
unsigned long & 32 & 0 a 4294967295 \tn 
% Row Count 22 (+ 2)
% Row 15
\SetRowColor{white}
float & 32 & 3.4E-38 a 3.4E+38 \tn 
% Row Count 23 (+ 1)
% Row 16
\SetRowColor{LightBackground}
double & 64 & 1.7E-308 a 1.7E+308 \tn 
% Row Count 24 (+ 1)
% Row 17
\SetRowColor{white}
long double & 64/80 & 1.7E-308 a 1.7E+308 o 3.4E-4932 a 1.1E+4932 \tn 
% Row Count 26 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}---}
\SetRowColor{LightBackground}
\mymulticolumn{3}{x{8.4cm}}{(!) char sin default e int signed y short por default.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}---}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{p{0.88 cm} x{7.12 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Redireccionamiento}}  \tn
% Row 0
\SetRowColor{LightBackground}
\textless{} & Entrada estandar \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
\textless{}2 & Entrada por error \tn 
% Row Count 2 (+ 1)
% Row 2
\SetRowColor{LightBackground}
\textgreater{} & Salida estandar \tn 
% Row Count 3 (+ 1)
% Row 3
\SetRowColor{white}
2\textgreater{} & Salida por error \tn 
% Row Count 4 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{p{0.8 cm} x{7.2 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Especificaciones de conversion para scanf}}  \tn
% Row 0
\SetRowColor{LightBackground}
\%*d & Se lee un entero pero sin guardarlo en ninguna variable. \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
\%3u & Longitud maxima, unsigned 3 \tn 
% Row Count 3 (+ 1)
% Row 2
\SetRowColor{LightBackground}
\%ho & la h quiere decir que es un short y la o que es octal \tn 
% Row Count 5 (+ 2)
% Row 3
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{\%*x} \tn 
% Row Count 6 (+ 1)
% Row 4
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{\%4f} \tn 
% Row Count 7 (+ 1)
% Row 5
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{\%*c} \tn 
% Row Count 8 (+ 1)
% Row 6
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{\%5s} \tn 
% Row Count 9 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{3.84 cm} x{4.16 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Structs}}  \tn
% Row 0
\SetRowColor{LightBackground}
Definicion & struct nombreRegistro\{    tipo1  nombreCampo1;    tipo2  nombreCampo2;    ...    tipoN  nombreCampoN; \}; \tn 
% Row Count 6 (+ 6)
% Row 1
\SetRowColor{white}
Declaracion variable de tipo struct & struct nombreRegistro \{ ... \} nombreVariable; \tn 
% Row Count 9 (+ 3)
% Row 2
\SetRowColor{LightBackground}
 & struct nombreRegistro \{ ... \};  struct nombreRegistro nombreVariable; \tn 
% Row Count 13 (+ 4)
% Row 3
\SetRowColor{white}
Usando typedef & typedef struct nombreOptativo\{ ... \} nombreTipo;  struct nombreOptativo unaVariable; nombreTipo otraVariable; //Estas dos formas de declarar una struct son equivalentes \tn 
% Row Count 22 (+ 9)
% Row 4
\SetRowColor{LightBackground}
Inicializacion & struct nombreStruct nombreVariable = \{dato1,  					dato2, ... , datoN\}; \tn 
% Row Count 26 (+ 4)
% Row 5
\SetRowColor{white}
Acceso al campo de una struct & variableStruct . nombreCampo \tn 
% Row Count 28 (+ 2)
% Row 6
\SetRowColor{LightBackground}
Parametro & \seqsplit{funcion(nombreVariableDeTipoEstructura);} \tn 
% Row Count 30 (+ 2)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{3.84 cm} x{4.16 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Structs (cont)}}  \tn
% Row 7
\SetRowColor{LightBackground}
Retornada en el nombre de una funcion & \seqsplit{nombreVariableDeTipoEstructura} = funcion(); \tn 
% Row Count 3 (+ 3)
% Row 8
\SetRowColor{white}
Asignacion de una estructura a otra & estructura1 = estructura2; \tn 
% Row Count 5 (+ 2)
% Row 9
\SetRowColor{LightBackground}
Tamaño de una estructura & Con sizeof \tn 
% Row Count 7 (+ 2)
% Row 10
\SetRowColor{white}
Posicion de un campo & \#include \textless{}stddef.h\textgreater{}  offsetof ( tipo , campo) \tn 
% Row Count 10 (+ 3)
% Row 11
\SetRowColor{LightBackground}
Operador flecha & p-\textgreater{}code es equivalente a (*p).code. Sirve cuando modifico una estructura que recibo como parametro en una funcion, que se recibe un puntero a estructura. \tn 
% Row Count 18 (+ 8)
% Row 12
\SetRowColor{white}
Bit fields & Para indicar cuántos bits ocupa cada campo entero. Ej:    unsigned int tamaño: 6;  // 6 bits \tn 
% Row Count 23 (+ 5)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{(!) Una struct como parametro de una funcion: Se envía al stack una copia de la estructura. Como se envía una copia, si la función modifica un campo, la variable original (el parámetro actual) no se ve alterada.  \newline (!) Las estructuras no puede ser comparadas}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{2.56 cm} x{5.44 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Listas}}  \tn
% Row 0
\SetRowColor{LightBackground}
Definicion & typedef​ struct node * TList;   typedef​ struct node \{ 	int elem; 	struct node * tail; \} TNode; \tn 
% Row Count 4 (+ 4)
% Row 1
\SetRowColor{white}
Argumento a funcion & double (*func) (double) \tn 
% Row Count 6 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{(!) Una lista vacía se representa con el valor ​NULL}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{3.52 cm} x{4.48 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Puntero a funcion}}  \tn
% Row 0
\SetRowColor{LightBackground}
Parametro & elemType (*function) (elemType) \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
Argumento & function \tn 
% Row Count 3 (+ 1)
% Row 2
\SetRowColor{LightBackground}
Arreglo de funciones & elemType (*arrayName{[}{]}) (elemType) = \{sin, cos, etc\}; \tn 
% Row Count 6 (+ 3)
% Row 3
\SetRowColor{white}
Ejecucion de funcion en arreglo & arrayName{[}index{]} (data); \tn 
% Row Count 8 (+ 2)
% Row 4
\SetRowColor{LightBackground}
Ejecucion de funcion & function(data); \tn 
% Row Count 10 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{(!) "data" lease como el argumento}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}


% That's all folks
\end{multicols*}

\end{document}