#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
int main( ) {
 
   FILE *fichero;
   FILE *fichero2;
   char buffer[1001];	/* bufer de linea, 1000 caracteres */
 
   char nombre[11] = "datos.txt";
   char nombre2[11]= "salida.txt";
 
   fichero = fopen( nombre, "r" );  // Fichero datos.txt desde el que leo los datos.
   fichero2= fopen( nombre2, "w");  // Fichero salida.txt donde escribire los datos.
   if ( fichero == NULL ) {
      printf( "Fichero '%s' no se pudo abrir.\n", nombre );		/* error */
      return -1;
   }
   if ( fichero2 == NULL ) {
      printf( "Fichero '%s' no se pudo abrir.\n", nombre2 );	/* error */
      return -1;
   }
 
   /* Mensaje al usuario */
   printf( "\nLeyendo los datos del fichero \"%s\":\n", nombre );
 
   /* Leer linea a linea, ponerlo en buffer y pasarlo al fichero2 convertido
    * a mayusculas */
  linea = 1;
   while ( !feof(fichero) ) {
      if ( fgets( buffer, 1001, fichero ) != NULL )
         printf("Linea %d: \n\t%s", linea++, buffer );
   }
 
   /* cerramos los ficheros abiertos */
   if( !fclose(fichero) )
      printf( "Fichero '%s' cerrado con exito\n", nombre );
   else
   {
      printf( "Error: fichero '%s' NO CERRADO\n", nombre );
      return -1;
   }
 
   if( !fclose(fichero2) )
      printf( "Fichero '%s' cerrado con exito\n", nombre2 );
   else
   {
      printf( "Error: fichero '%s' NO CERRADO\n", nombre2 );
      return -1;
   }
 
   getchar();
   return 0;
}

Leyendo los datos del fichero "datos.txt":
Linea 1: 
	Hola
Linea 2: 
	Mundo
Linea 3: 
	Hugo Paco Luis
Linea 4: 
	
Fichero 'datos.txt' cerrado con exito
Fichero 'salida.txt' cerrado con exito

• paréntesis
• números
• operadores aritméticos binarios: + - * / % ^
• operadores unarios (por incluir en el futuro): sin(), cos(), exp(), log(), etc.
• caracteres de espacio, mismos que son ignorados

Posfijo es: 
	 2 1 3 4 5 + * + *

Evaluando la expresion ...
	operar 4+5 = 9
	operar 3*9 = 27
	operar 1+27 = 28
	operar 2*28 = 56
El resultado es: 56

Intro expresion infija: 5 + 2 * 3

Analizando token: '5'
	es numero: pasado a posfijo

Analizando token: '+'
	es operador:
	colocar '+' en la pila

Analizando token: '2'
	es numero: pasado a posfijo

Analizando token: '*'
	es operador:
	colocar '*' en la pila

Analizando token: '3'
	es numero: pasado a posfijo

Pasado operador '*' de la pila a posfijo

Pasado operador '+' de la pila a posfijo

Posfijo es: 
	 5 2 3 * +

Evaluando la expresion ...
	operar 2*3 = 6
	operar 5+6 = 11
El resultado es: 11

Analizando token: '5'
	es numero: pasado a posfijo

Analizando token: '+'
	es operador:
	colocar '+' en la pila

Analizando token: '3'
	es numero: pasado a posfijo

Analizando token: '*'
	es operador:
	colocar '*' en la pila

Analizando token: '('
pasado a posfijo

Analizando token: '4'
	es numero: pasado a posfijo

Analizando token: '-'
	es operador:
	colocar '-' en la pila

Analizando token: '7'
	es numero: pasado a posfijo

Analizando token: ')'
	pasado operador '-' de la pila a posfijo

Analizando token: '^'
	es operador:
	colocar '^' en la pila

Analizando token: '2'
	es numero: pasado a posfijo

Analizando token: '-'
	es operador:
	pasado operador '^' de la pila a posfijo
	pasado operador '*' de la pila a posfijo
	pasado operador '+' de la pila a posfijo
	colocar '-' en la pila

Analizando token: '1'
	es numero: pasado a posfijo

Pasado operador '-' de la pila a posfijo

Posfijo es: 
	 5 3 4 7 - 2 ^ * + 1 -

Evaluando la expresion ...
	operar 4-7 = -3
	operar -3^2 = 9
	operar 3*9 = 27
	operar 5+27 = 32
	operar 32-1 = 31
El resultado es: 31

#include <cstdlib>
#include <iostream>
#include <string>
#include <stack>
#include <cmath>
 
using namespace std;
 
/* Operadores matematicos */
#define N_operators 6
const string operators[N_operators] = {"+", "-", "*", "/", "%", "^"};
int precedences[N_operators] = {1, 1, 2, 2, 2, 3};
 
bool is_operator( const string );
int precedence( const string );
 
/* Mis sugerencias personales a este programa: 
 * 
 * - Considerar el cambio del nombre standby por aux_stack, u otro. 
 * - Incorporar el analizador lexico para expresiones numericas de punto
 *   flotante, o que ocupen mas de un caracter.
 * - Eliminar la cadena intermedia postfix, pasando directamente los 
 *   resultados de la pila de operadores extraidos de infix, a una pila
 *   de evaluacion. 
 * - Incorporar operadores unarios, como sin(), cos(), exp(), log(), etc.
 * - Detectar errores de sintaxis en la expresion infija. 
 * - Otros que sean recomendados.
 */
 
int main() {
 
	string infix, postfix, token;
	stack <string> standby;
	stack <double> result;
	size_t i;
	char c;
	double A, B;
 
	/* Cadena de entrada */
	cout << "Intro expresion infija: ">
	getline( cin, infix );
	cout << endl;
 
	/*************************************************************
	  PRIMERA PARTE: Procesar la cadena infijo, y crear posfijo 
	 *************************************************************/
	for ( i = 0; i < infix.size(); i++ ) {
		/* esto debe cambiar luego a un token o palabra devuelta por
		 * el analizador léxico */
		c = infix[i];
		token.clear();
		token += c;			/* parece burdo, pero no conozco mejor manera de 
								 * crear un string a partir de un unico caracter */
 
		/* es un espacio: despreciar */
		if ( c == ' ' ) continue;
 
		cout << "Analizando token: '" << c << "'" << endl;
 
		/* es un carácter numérico: pasar al posfijo */
		if ( c >= '0' && c <= '9' ) {
			cout << "\tes numero: pasado a posfijo" << endl << endl;
			postfix = postfix + " " + c;
			continue;
		}
 
		/* si se lee un operador: sacar de la pila y pasar al postfijo
		 * todos los operadores con una precedencia mayor o igual a la 
		 * suya, y depositar el mismo en la pila */
		if ( is_operator( token ) ) {
			cout << "\tes operador:" << endl;
			while ( !standby.empty() && precedence( standby.top() ) 
						>= precedence( token ) ) {
				cout << "\tpasado operador '" + standby.top() + 
					"' de la pila a posfijo" << endl;
				postfix = postfix + " " + standby.top();
				standby.pop();
			}
			standby.push( token );
			cout << "\tcolocar '" << token << "' en la pila" << endl << endl;
			continue;
		}
 
		/* si se lee "(": colocar en la pila */
		if ( token == "(" ) {
			cout << "pasado a posfijo" << endl << endl;
			standby.push( token );
			continue;
		}
 
		/* si se lee ")": retirar de la pila hasta encontrar '(', y pasar 
		 * los elementos retirados a posfijo, luego descartar el "(" */
		if ( token == ")" ) {
			while ( !standby.empty() && standby.top() != "(" ) {
				cout << "\tpasado operador '" + standby.top() + 
					"' de la pila a posfijo" << endl << endl;
				postfix = postfix + " " + standby.top();
				standby.pop();
			}
			if ( !standby.empty() )
				standby.pop();	/* descartar el "(" */
		}
	}
 
	/* extraer de la pila cualquier operador restante y pasarlo a la cadena posfijo */
	while ( !standby.empty() ) {
		cout << "Pasado operador '" + standby.top() + 
			"' de la pila a posfijo" << endl << endl;
		postfix = postfix + " " + standby.top();
		standby.pop();
	}
 
	/* Imprimir el posfijo */
	cout << "Posfijo es: \n\t" << postfix << endl << endl;
 
	/****************************************************************
	  SEGUNDA PARTE: Procesar la cadena posfijo, y devolver resultado
	 ****************************************************************/
 
	A = 0;
	cout << "Evaluando la expresion ..." << endl;
	for ( i = 0; i < postfix.size(); i++ ) {
 
		c = postfix[i];
		token.clear();
		token += c;
 
		/* si se lee un operando (caracter numerico), depositar en la pila */
		if ( c >= '0' && c <= '9' ) {
			result.push( c - '0' );
			continue;
		}
 
		/* si se lee un operador binario, poner en A y B los últimos dos argumentos 
		 * de la pila y operarlos, guardando el resultado en la pila */
		if ( is_operator( token ) ) {
			if ( !result.empty() ) {
				B = result.top();
				result.pop();
			}
			else {
				cout << "Argumentos insuficientes para '" << c << "'" << endl;
				return -1;
			}
 
			if ( !result.empty() ) {
				A = result.top();
				result.pop();
			}
			else {
				cout << "Argumentos insuficientes para '" << c << "'" << endl;
				return -1;
			}
 
			cout << "\toperar " << A << token << B << " = ";
			if ( token == "+" ) {
				A += B;
				result.push( A );
			}
			else if ( token == "-" ) {
				A -= B;
				result.push( A );
			}
			else if ( token == "*" ) {
				A *= B;
				result.push( A );
			}
			else if ( token == "/" ) {
				A /= B;
				result.push( A );
			}
			else if ( token == "%" ) {
				A = (int )A % (int )B;
				result.push( A );
			}
			else if ( token == "^" ) {
				A = pow(A, B);
				result.push( A );
			}
			cout << A << endl;
		}
	}
 
	if ( !result.empty() )
		cout << endl << "El resultado es: " << result.top() << endl;
 
	return 0;
}
 
/* Verdadero si el token corresponde a un operador. */
bool is_operator( const string token ) {
 
	for ( int i = 0; i < N_operators; i++ )
		if ( operators[i] == token ) 
			return true;
 
	return false;
}
 
/* Devuelve la precedencia del operador descrito por el
 * string token (-1 si no es un operador) */
int precedence( const string token ) {
 
	for ( int i = 0; i < N_operators; i++ )
		if ( operators[i] == token ) 
			return precedences[i];
 
	return -1;
}

for ( i = 1; i < n; i++ ) {
    A = B = 1;
    for ( j = i; j <= i; j++ ) {
        A *= n - j + 1;
        B *= j;
    }
    comb[i] = A / B;
 

long long * FilaTrianguloPascal( int n ) {
 
   int i, j;
   long long A, B, * fila;
 
   if ( ( fila = (long long *) malloc( (n + 1) *sizeof(long long) ) ) == NULL )
      return NULL;
 
   fila[0] = fila[n] = 1;
 
   A = 1;		/* numerador */
   B = 1;		/* denominador */
   for ( i = 1; i < n; i++ ) {
      /* mitad izquierda de la fila */
      if ( i <= n / 2 ) {
         A *= n - i + 1;
         B *= i;
         fila[i] = A / B;
      }
      /* mitad derecha */
      else
         fila[i] = fila[n - i];
   }
 
   return fila;
}