#include <string.h>
#include <stdio.h>
 
#define MAX_PATH 4096
 
int main() {
	// Puedes poner MAX_PATH como quieras, o saber este valor a través de librerías
	// no estándares
	char ruta_entrada[MAX_PATH];
	char ruta_salida[MAX_PATH];
	FILE *entrada;
	FILE *salida;
	char byte;
	int salir = 0;
 
	// Obtenemos rutas
	fprintf(stdout, "Introduzca la ruta del archivo a copiar: ");
	fgets(ruta_entrada, MAX_PATH, stdin);
	ruta_entrada[strlen(ruta_entrada) - 1] = '\0';
	fprintf(stdout, "Introduzca la ruta del archivo de destino: ");
	fgets(ruta_salida, MAX_PATH, stdin);
	ruta_salida[strlen(ruta_salida) - 1] = '\0';
 
	// Abrimos archivos
	entrada = fopen(ruta_entrada, "rb");
	if(NULL == entrada) {
		fprintf(stderr, "Error abriendo archivo de entrada en '%s'\n", ruta_entrada);
		perror("Detalles");
		return -1;
	}
 
	salida = fopen(ruta_salida, "wb");
	if(NULL == salida) {
		fprintf(stderr, "Error abriendo archivo de salida en '%s'\n", ruta_salida);
		perror("Detalles");
		return -1;
	}
 
	// Copiando datos
	while(0 == salir) {
		byte = fgetc(entrada);
 
		if(0 == feof(entrada)) {
			fputc(byte, salida);
 
			if(0 != ferror(entrada) || 0 != ferror(salida)) {
				fprintf(stderr, "Error leyendo|escribiendo byte\n");
				perror("Detalles");
				return -1;
			}
		} else {
			salir = 1;
		}
	}
 
	// Terminando...
	fprintf(stdout, "La copia de archivos ha finalizado\n");
 
	fclose(entrada);
	fclose(salida);
	return 0;
}

BITS 16
 
start:
	xor ax, ax                 ; Set data segment to where we're loaded
	mov ds, ax
 
	mov ax, text_string
	add ax, 7C00h
	mov si, ax                 ; Put string position into SI
	call print_string          ; Call our string-printing routine
 
	jmp $                      ; Jump here - infinite loop!
 
 
text_string: db 'This is my cool new OS!', 0
 
 
print_string:                      ; Routine: output string in SI to screen
	mov ah, 0Eh                ; int 10h 'print char' function
 
.repeat:
	lodsb                      ; Get character from string
	cmp al, 0
	je .done                   ; If char is zero, end of string
	int 10h                    ; Otherwise, print it
	jmp .repeat
 
.done:
	ret
 
 
	times 510-($-$$) db 0      ; Pad remainder of boot sector with 0s
	dw 0xAA55

BITS 16
 
start:
	xor ax, ax                 ; Lo ponemos como 0
	mov ds, ax
 
	mov ax, text_string        ; Calculo manualmente la dirección de la caedna
	add ax, 7C00h
	mov si, ax                 ; La guardo en SI
 
        ...

BITS 16
 
start:
	mov ax 0x07C0          ; Lo ponemos como 0
	mov ds, ax
 
	mov ax, text_string    ; El cálculo debería ser DS * 0x10 + SI, lo que es lo mismo que 
                               ; 0x07C0 * 0x10 + SI, lo que es lo mismo que 0x7C00 + SI, que
                               ; a su vez es lo mismo que el cálculo manual antes expuesto
	mov si, ax             ; La guardo en SI
 
        ...

mov ah, 0x00
SAHF
CLC
CLD
CLTS
mov ax, 0x07C0
mov ds, ax

xor ax, ax            ; Algo más tiene que hacer XOR, porque aun reemplazando el valor de ax, sin XOR no funciona
mov ax, 0x07C0        ; Aquí reemplazamos todo ax
mov ds, ax

          #include<stdio.h>
 
 
 
 
                 int
                main(
               ){float
              rad=0.0f;
             float peri;
            float   areac
           =.0f;     const
          float       pi_2=
         1.5707f;char*areas=
        "Area";fprintf(stdout
       ,"Radio: ");scanf("%f",
      &rad);              peri=
     4.00f                 *pi_2
    *rad;                   areac
   =2.0f                     *pi_2
  *rad*                       *&rad
;fprintf                     (stdout,
 
 
 
 
"Perimeter: %f\n",peri);fprintf(stdo\
ut,"%s: %f",areas, areac); return 0;}

C:/MinGW64/mingw64/x86_64-w64-mingw32/include/c++/ostream:574:5: note:   templat
e argument deduction/substitution failed:
clasesvehiculo/vehiculo.cpp:109:52: note:   cannot convert 'Vehiculo::mostrarPre
cio()' (type 'void') to type 'const unsigned char*'
                 cout << "Precio: " << mostrarPrecio() << endl;
                                                    ^

void Vehiculo::mostrarPrecio()
{
        return precio;
}
 
[...]
 
void Vehiculo::mostrarVehiculo()
{
        [...]
        cout << "Precio: " << mostrarPrecio() << endl;
}

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#include <stdlib.h>
#include <stdio.h>
 
typedef struct {
	unsigned char *bytes;
	unsigned int num_bytes;
} big_int;
 
void set_big_int(big_int *result, unsigned char number);
void multiply(big_int *result, unsigned char number);
void divide(big_int *result, unsigned char denominator);
unsigned char get_module(big_int *result, unsigned char denominator);
void factorial(big_int *result, unsigned char number);
int is_zero(big_int *big_integer);
 
int main() {
	big_int big_integer = {NULL, 0};
	unsigned char digit;
	unsigned int num_digits = 0;
	unsigned int result = 0;
 
	fprintf(stdout, "Adding all digits of 200!...\n");
 
	factorial(&big_integer, 200);
 
	while(is_zero(&big_integer) == 0) {
		num_digits++;
 
		digit = get_module(&big_integer, 10);
		fputc(digit + '0', stdout);
		result += digit;
 
		divide(&big_integer, 10);
	}
 
	fprintf(stdout, "\n\nDigit sum result: %u\n", result);
	fprintf(stdout, "Number of digits: %u", num_digits);
 
	fgetc(stdin);
	return 0;
}
 
void set_big_int(big_int *result, unsigned char number) {
	if(result->bytes != NULL)
		free(result->bytes);
 
	result->bytes = malloc(sizeof(unsigned char));
	result->bytes[0] = number;
	result->num_bytes = 1;
}
 
void multiply(big_int *result, unsigned char number) {
	register int i;
	unsigned int rest = 0;
 
	for(i = 0; i < result->num_bytes; i++) {
		rest = result->bytes[i] * number + rest;
		result->bytes[i] = rest & 0x000000FF;
		rest >>= 8;
 
		if(rest != 0 && i+1 == result->num_bytes) {
			result->num_bytes += 1;
			realloc(result->bytes, result->num_bytes);
			result->bytes[i+1] = 0;
		}
	}
}
 
void divide(big_int *result, unsigned char denominator) {
	register int i;
	unsigned int module = 0;
	unsigned int new_size = result->num_bytes;
 
	for(i = result->num_bytes-1; i >= 0; i--) {
		module = (unsigned int)result->bytes[i] + (module << 8);
		result->bytes[i] = module/denominator;
		module %= denominator;
	}
 
	for(i = result->num_bytes-1; i >= 0 && result->bytes[i] == 0; i--)
		new_size--;
 
	if(new_size != result->num_bytes) {
		result->num_bytes = new_size;
		realloc(result->bytes, new_size);
	}
}
 
unsigned char get_module(big_int *result, unsigned char denominator) {
	register int i;
	unsigned int module = 0;
 
	for(i = result->num_bytes-1; i >= 0; i--)
		module = ((unsigned int)result->bytes[i] + (module << 8))%denominator;
 
	return module;
}
 
void factorial(big_int *result, unsigned char number) {
	unsigned char i;
 
	set_big_int(result, 1);
	for(i = 2; i <= number; i++)
		multiply(result, i);
}
 
int is_zero(big_int *big_integer) {
	register unsigned int i;
	unsigned int result = 1;
 
	for(i = 0; result == 1 && i < big_integer->num_bytes; i++)
		result = big_integer->bytes[i] == 0;
 
	return result;
}

00000000000000000000000000000000000000000000000002747379830732698722222987169785
80071532604230714091306220668659755047521230423093757042424257723584928247221314
68192330452042466154126544229349889693732713367072758264311139928259426629160501
73624209724675203883691983121277140932648911048240302924330436994495344233524749
2362371786779531592260581239312363255305097463768756887

Digit sum result: 1404
Number of digits: 375