Oye muchísimas gracias por la información , lo he instalado y he activado la opción Opera Turbo y esto vá a las mil maravillas!

Tienes razón daniyo , el preprocesador tiene que realizar más condiciones , así se "optimiza" o así lo creo el trabajo de éste.

¡Anda ya como va a ser mío , el trabajo del code es tuyo! Claro que te lo pruebo ¡y con mucho gusto!

¡Un saludo!

A ver a ver yo tampoco entiendo el code podria estar comentado o algo de eso porque imaginarme lo que es no puedo.En cuanto a lo de que el programa esté activo declarar clases, ¿puedes declarar variables cuando el programa está activo?¿Puedes declarar estructuras cuando el programa está activo? Pues lo mismo con las clases.Código de ejemplo:

#include<iostream>
class chucho
{
public:
void lamer();
void comer();
void dormir();
};
int main() //Aqui el programa ya esta activo
{
   int variable_creada=0; //Podemos declarar una variable.
   if(variable_creada==1) //O no hacerlo
   {
      int variable2;          //Es creada si variable_creada es igual que uno
   }
   //Si no no la creamos del mismo modo podemos declarar clases.
  chucho yorkshire; 
  chucho pastor_aleman;
  chucho dalmata;
}

¿Tienes bien configurado codeblocks con Qt?
EDITO: Mira lo que pone al final http://unadequeso.blogspot.com.es/2008/06/instalar-qt-con-codeblocks.html

Gracias por el detalle Durasno ahora lo cambio que tengo que quitar también un fflush(stdin) que he visto por ahí.
¡Un saludo!

No entiendo el problema que planteas , ¿quieres cargar un montón de numeros aleatorios que no sean repetidos en una matriz? Mmmmm ¿tienes algo pensado o algún código hecho?

PD : Bienvenido al foro   

Bueno Dryken no estaría mal , aquí te dejo tu código con algunas mejoras:

• Portabilidad de código utilizando lo que ha dicho daniyo que se me ha adelantado.
• "Limpieza de código" , estructurado en un archivo principal , uno de cabecera y otro con sus funciones.
• Añadida función para pasar de binario a decimal y viceversa(no funcionaba).
• Ahora todas las variables no se declaran todas de golpe solo cuando se necesitan.
• Alguna que otra mejora superficial en alguna parte del código.

Te dejo el código de tu estupenda calculadora:
Archivo principal main.c

#include"funciones.h"
 
int main()
{
    int opc1;
    do
    {
        imprime_menu();
        scanf("%d", &opc1);
        limpiar;
        switch(opc1)
        {
 
        case 1:
            sumar();
            break;
        case 2:
            restar();
            break;
        case 3:
            multiplicacion();
            break;
        case 4:
            division();
            break;
        case 5:
            raiz_cuadrada();
            break;
        case 6:
            potencia();
            break;
        case 7:
            logaritmo();
            break;
        case 8:
            seno();
            break;
        case 9:
            coseno();
            break;
        case 10:
            tangente();
            break;
        case 11:
            cosecante();
            break;
        case 12:
            secante();
            break;
        case 13:
            cotangente();
            break;
        case 14:
            conversion();
 
            break;
        case 15:
            multiplos();
            break;
        case 16:
            binomio();
            break;
        case 17:
            descuento();
            break;
        case 18:
            multiplicar_matriz();
            break;
        case 19:
            area_triangulo();
            break;
        case 20:
            break;
        default :
            printf("\nElije una de las opciones mostradas.\n\n");
            parar;
            limpiar;
        }
    }
    while(opc1!=20);
    return 0;
}
 

Archivo de cabecera "funciones.h"

#ifndef FUNCIONES_H_INCLUDED
#define FUNCIONES_H_INCLUDED
 
#ifdef __unix__      //Si esta definida la macro __unix__
#include<unistd.h>   //Incluimos esta libreria para sleep y system
#elif defined _WIN32 //Si no esta definida, pero esta definida la macro _WIN32
#include<windows.h>  //Incluimos esta libreria para Sleep y system
#endif               //Termina el if
 
#ifdef __unix__
#define limpiar system("clear")
#elif defined _WIN32
#define limpiar system("cls")
#endif
 
#ifdef __unix__
#define parar sleep(2)
#elif defined _WIN32
#define parar Sleep(2500)
#endif
 
#include<math.h>     //Libreria para las operaciones matematicas.
#include<stdio.h>    //Libreria para la entrada/salida.
#include<stdint.h>   //Libreria con todos los tipos de enteros.
#include<stdlib.h>   //Libreria de proposito general aunque la usamos para gestionar la memoria dinamica.
#include<string.h>   //Libreria para el manejo de cadenas.
 
//****************************************//
//          CONTROL DEL PROGRAMA         *//
//---------------------------------------*//
void imprime_menu();//                    *//
//****************************************//
 
//*************************************************//
//FUNCION PARA LLAMAR A LAS CONVERSIONES DE MONEDA*//
//------------------------------------------------*//
void conversion();//                     *//
//****************************************//
//* SET DE CONVERSION EURO -> MONEDA     *//
//****************************************//
void euros_a_pesetas();//                *//
void euros_a_yenes();//                  *//
void euros_a_dolares();//                *//
//****************************************//
//* SET DE CONVERSION MONEDA -> EURO     *//
//****************************************//
void dolares_a_euros();//                *//
void yenes_a_euros();//                  *//
void pesetas_a_euros();//                *//
//****************************************//
 
//****************************************//
//* SET DE CONVERSION SISTEMAS NUMERICOS *//
//****************************************//
void decimal_a_binario();//              *//
void binario_a_decimal();//              *//
//****************************************//
//****************************************//
//    SET DE OPERACIONES ARITMETICAS     *//
//---------------------------------------*//
void sumar();//                          *//
void restar();//                         *//
void multiplicacion();//                 *//
void division();//                       *//
//****************************************//
 
//****************************************//
//            OPERACION RAIZ             *//
//---------------------------------------*//
void raiz_cuadrada();//                  *//
//****************************************//
 
//**************************************************//
//           OPERACION POTENCIA                    *//
//-------------------------------------------------*//
void potencia();//                                 *//
uint64_t pow_uint64(uint64_t base, uint32_t exp);//*//
//**************************************************//
//****************************************//
//           OPERACION LOGARITMO         *//
//---------------------------------------*//
void logaritmo();//                      *//
//****************************************//
//****************************************//
//   SET DE OPERACIONES TRIGONOMETRICAS  *//
//---------------------------------------*//
void seno();        void cosecante();//  *//
void coseno();      void secante();//    *//
void tangente();    void cotangente();// *//
//****************************************//
 
//****************************************//
//    SET DE OPERACIONES CON MATRICES    *//
//---------------------------------------*//
void multiplicar_matriz();//             *//
//****************************************//
 
//****************************************//
//      SET DE OPERACIONES DE AREAS      *//
//---------------------------------------*//
void area_triangulo();//                 *//
//****************************************//
 
//****************************************//
//        SET DE OTRAS OPERACIONES       *//
//---------------------------------------*//
void multiplos();//                      *//
void binomio();//                        *//
void descuento();//                      *//
void invertir_cadena(char *cadena);//    *//
//****************************************//
 
 
#endif // FUNCIONES_H_INCLUDED
 

Archivo con las definiciones de las funciones "funciones.c"

#include "funciones.h"
void imprime_menu()
{
    printf("\nElije la operaci%cn a realizar: ",162);
    printf("\n-----------------------------");
    printf("\n\n1-Suma\t\t\t8-Sen\t\t14-Conversor");
    printf("\n2-Resta\t\t\t9-Cos\t\t15-Conocer m%cltiplos",163);
    printf("\n3-Multiplicaci%cn\t10-Tang\t\t16-Teorema Binomio",162);
    printf("\n4-Divisi%cn\t\t11-Cosec\t17-Calcular un descuento",162);
    printf("\n5-Ra%cz\t\t\t12-Sec\t\t18-Multiplicar 2 matrices",161);
    printf("\n6-Potencia\t\t13-Cotang\t19-Area de un triangulo");
    printf("\n7-Logaritmo\t\t\t\t20-Salir\t\t\t");
}
void conversion()
{
    int opc2=0;
 
    do
    {
        printf("\nElije el formato:\n");
        printf("-----------------\n\n");
        printf("1-Euros->Pesetas\t\t2-Pesetas->Euros\n\n3-Euros->Dolares\t\t4-Dolares->Euros\n\n5-Euros->Yenes\t\t\t6-Yenes->Euros\n\n7-Decimal->Binario\t\t8-Binario->Decimal\n\n9-Volver\t");
        scanf("%d",&opc2);
        limpiar;
        switch(opc2)
        {
 
        case 1:
            euros_a_pesetas();
            break;
        case 2:
            pesetas_a_euros();
            break;
        case 3:
            euros_a_dolares();
            break;
        case 4:
            dolares_a_euros();
            break;
        case 5:
            euros_a_yenes();
            break;
        case 6:
            yenes_a_euros();
            break;
        case 7:
            decimal_a_binario();
            break;
        case 8:
            binario_a_decimal();
            break;
        case 9:
            break;
        default :
            printf("\nElije una de las opciones mostradas.\n\n");
            parar;
            limpiar;
        }
    }
    while(opc2!=9);
}
 
void euros_a_pesetas()
{
    float num;
    printf("\nIntroduce la cantidad de euros a transformar:\t");
    scanf("%f", &num);
    printf("\nSon: %f Pesetas", num*166);
}
void pesetas_a_euros()
{
    float num;
    printf("\nIntroduce la cantidad de pesetas a transformar:\t");
    scanf("%f",&num);
    printf("\nSon: %f Euros",num/166);
}
void euros_a_dolares()
{
 
    float num;
    printf("\nIntroduce la cantidad de euros a transformar:\t");
    scanf("%f",&num);
    printf("\nSon: %f Dolares",num/0.8136);
}
void dolares_a_euros()
{
    float num;
    printf("\nIntroduce la cantidad de dolares a transformar:\t");
    scanf("%f",&num);
    printf("\nSon: %f Euros",num/1.2616);
}
void euros_a_yenes()
{
    float num;
    printf("\nIntroduce la cantidad de euros a transformar:\t");
    scanf("%f",&num);
    printf("\nSon: %f Yenes",num*97.7538829);
}
void yenes_a_euros()
{
    float num;
    printf("\nIntroduce la cantidad de yenes a transformar:\t");
    scanf("%f",&num);
    printf("\nSon: %f Euros",num*0.0102297727);
}
void sumar()
{
    double numero1, numero2;
    printf("\nIntroduce el primer n%cmero a sumar:\t",163);
    scanf("%lf",&numero1);
    printf("Introduce el segundo n%cmero a sumar:\t",163);
    scanf("%lf",&numero2);
    printf("\nEl resultado es:  %f",numero1+numero2);
}
void restar()
{
    double numero1, numero2;
    printf("\nIntroduce el primer n%cmero a restar:\t",163);
    scanf("%lf",&numero1);
    printf("Introduce el segundo n%cmero a restar:\t",163);
    scanf("%lf",&numero2);
    printf("\nEl resultado es:  %lf",numero1-numero2);
}
void multiplicacion()
{
    double numero1, numero2;
    printf("\nIntroduce el primer multiplicante:\t");
    scanf("%lf",&numero1);
    printf("Introduce el segundo multiplicante :\t");
    scanf("%lf",&numero2);
    printf("\nEl resultado es:  %lf",numero1*numero2);
}
void division()
{
    double numero1, numero2;
    printf("\nIntroduce el dividendo:\t");
    scanf("%lf",&numero1);
    printf("Introduce el divisor:\t");
    scanf("%lf",&numero2);
    printf("\nEl cociente es: %lf\nEl resto de la division entera es: %d",numero1/numero2, ((int)numero1)%(int)(numero2));
 
}
void raiz_cuadrada()
{
    double numero1;
    printf("\nIntroduce el n%cmero del cual deseas sacar la raiz:\t",163);
    scanf("%lf",&numero1);
    printf("\nEl resultado es:  %lf", sqrt(numero1));
}
void potencia()
{
    double numero1, numero2;
    printf("\nIntroduce la base:\t");
    scanf("%lf",&numero1);
    printf("Introduce el exponente:\t");
    scanf("%lf",&numero2);
    printf("\nEl resultado es:  %lf",pow(numero1,numero2));
}
void logaritmo()
{
    double numero1;
    printf("\nIntroduce el n%cmero (base 10 por defecto):\t",163);
    scanf("%lf",&numero1);
    printf("\nEl resultado es:  %lf",log10(numero1));
}
void seno()
{
    double numero1;
    printf("\nIntroduce el n%cmero a hallar el seno:\t",163);
    scanf("%lf",&numero1);
    printf("\nEl resultado es:  %f",sin(numero1));
}
void coseno()
{
    double numero1;
    printf("\nIntroduce el n%cmero a hallar el coseno:\t",163);
    scanf("%lf",&numero1);
    printf("\nEl resultado es:  %f",cos(numero1));
}
void tangente()
{
    double numero1;
    printf("\nIntroduce el n%cmero a hallar la tangente:\t",163);
    scanf("%lf",&numero1);
    printf("\nEl resultado es:  %lf",tan(numero1));
}
void cosecante()
{
    double numero1;
    printf("\nIntroduce el n%cmero a hallar el cosecante:\t",163);
    scanf("%lf",&numero1);
    printf("\nEl resultado es:  %lf",asin(numero1));
}
void secante()
{
    double numero1;
    printf("\nIntroduce el n%cmero a hallar el secante:\t",163);
    scanf("%lf",&numero1);
    printf("\nEl resultado es:  %lf",acos(numero1));
}
void cotangente()
{
    double numero1;
    printf("\nIntroduce el n%cmero a hallar el cotangente:\t",163);
    scanf("%lf",&numero1);
    printf("\nEl resultado es:  %lf",atan(numero1));
}
void multiplos()
{
    unsigned long int num,cifras;
    printf("Introduce el numero a conocer sus m%cltiplos ---> ",163);
    scanf("%lu",&num);
    printf("%cHasta que cifras deseas conocer los m%cltiplos del %lu ---> ",168,163,num);
    scanf("%lu",&cifras);
    for(int i=1; cifras!=0; ++i)
    {
        printf("%lu ",num*i);
        --cifras;
    }
}
void binomio()
{
    long n, k, nf, kf, resta, restaf, v, w;
    printf( "\nIngrese n y k: " );
    fflush( stdout);
    scanf( "%ld %ld", &n, &k );
    nf = 1;
    kf = 1;
    resta = n - k;
    restaf = 1;
    while ( n > 1 )    /* factorial de n */
    {
        nf *= n--;
    }
    while ( k > 1 )    /* factorial de k */
    {
        kf *= k--;
    }
    while ( resta > 1 )    /* factorial de (n - k) */
    {
        restaf *= resta--;
    }
    v = kf * restaf; /* k! * (n - k)! */
    w = nf / v; /* n! / (k! * (n - k)!) */
    /* resultados */
    printf( "\nn! = %ld\n"
            "k! = %ld\n"
            "(n - k)! = %ld\n"
            "k! * (n - k)! = %ld\n"
            "n! / [k! (n - k)!] = %ld\n"
            "--------------------------\n"
            "Resultado final (ncr): %ld\n", nf, kf, restaf, v, w, w );
}
void descuento()
{
    int opcioniva;
    char producto[25];
    double precio, descuento, res, preciodesc, precioiva, precioiva2;
    printf("\nIntroduce el nombre del producto:    ");
    while(getchar()!='\n'){}
    fgets(producto, sizeof(producto), stdin);
    producto[strlen(producto)-1] = '\0';
    printf("\n%cDicho producto incluye IVA?:\n\n1-Si      2-No    ",168);
    scanf("%d", &opcioniva);
    if(opcioniva==1)
    {
        printf("\nIntroduce el precio del producto:       ");
        scanf("%lf", &precio);
        printf("Introduce su descuento en porcentaje:   ");
        scanf("%lf", &descuento);
 
        preciodesc=precio*descuento/100;
        res=precio-preciodesc;
 
        printf("\nEl descuento del %s es de %lf euros", producto, preciodesc);
        printf("\n\nEl precio final del %s es de %lf euros", producto, res);
    }
    else
    {
 
        printf("\nIntroduce el precio del producto:       ");
        scanf("%lf", &precio);
        printf("Introduce su descuento en porcentaje:   ");
        scanf("%lf", &descuento);
        precioiva=precio*18/100;
        precioiva2=precioiva+precio;
        preciodesc=precioiva2*descuento/100;
        res=precioiva2-preciodesc;
        printf("\nEl precio del %s con iva es de %lf euros\n", producto, precioiva2);
        printf("\nEl descuento del %s es de %lf euros", producto, preciodesc);
        printf("\n\nEl precio final del %s es de %lf euros", producto, res);
    }
}
void multiplicar_matriz()
{
    int n3,m3,o3,p3,i3,j3,k3,a3[10][10],b3[10][10],c3[10][10];
    printf("\n\n%cCuantas filas tendra la matriz A?: ",168);
    scanf("%d", &m3);
    printf("\n%cCuantas columnas tendra la matriz A?: ",168);
    scanf("%d", &n3);
    printf("\n%cCuantas filas tiene la matriz B?: ",168);
    scanf("%d", &o3);
    printf("\n%cCuantas columnas tendra la matriz B?: ",168);
    scanf("%d", &p3);
    /*Reconoce si se puede realizar la multiplicacion*/
    if(m3!=p3)
    {
        printf("\n\nEl n%cmero de columnas de la matriz \"A\" es diferente al n%cmero de filas \nde la matriz \"B\"",163,163);
        printf("\n\nEl producto matricial no es posible de realizar.\n\n");
    }
    else
    {
        for (i3=1; i3<=m3; i3++)  /*Ciclo anidado que captura la matriz A*/
        {
            for (j3=1; j3<=n3; j3++)
            {
                printf("\nDame el elemento A(%i,%i)(fila/columna): ", i3,j3);
                scanf("%i", &a3[i3][j3]);
            }
        }
        for (i3=1; i3<=o3; i3++) /*Ciclo anidado que captura la matriz B*/
        {
            for (j3=1; j3<=p3; j3++)
            {
                printf("\nDame el elemento B(%i,%i)(fila/columna): ", i3,j3);
                scanf("%i", &b3[i3][j3]);
            }
        }
        for (i3=1; i3<=m3; i3++) /*Ciclo anidado que multiplica las 2 matrices*/
        {
            for (j3=1; j3<=p3; j3++)
            {
                c3[i3][j3]=0; /*Limpia la variable para entrar de nuevo al for*/
                for (k3=1; k3<=n3; k3++);
                c3[i3][j3]=(c3[i3][j3]+a3[i3][k3])*b3[k3][j3];
            }
        }
        printf("\n\nLa matriz resultante de la multiplicacion es: \n");
        /*Ciclo que imprime la matriz resultante*/
        for (i3=1; i3<=m3; i3++);
        {
            printf("\n");
            for(j3=1; j3<=p3; j3++);
            printf(" %i ",c3[i3][j3]);
        }
    }
 
 
}
void area_triangulo()
{
    double numero1,numero2;
    printf("\nIntroduce la base:\t");
    scanf("%lf",&numero1);
    printf("Introduce la altura:\t");
    scanf("%lf",&numero2);
    printf("El %crea del triangulo es %lf",160,(numero1*numero2)/2);
}
void decimal_a_binario()
{
 
    uint64_t dec;
    printf("Dame un numero en decimal:");
    scanf("%I64u",&dec);
 
    char *resultado=calloc(64*8,sizeof(char));
    char *presultado=resultado;
    if(dec/2==0) {}
    else
    {
        while(dec!=1)
        {
            *resultado=(dec%2)+48;
            dec/=2;
            ++resultado;
        }
 
        *resultado=49;
        invertir_cadena(presultado);
        printf("Su numero en binario es %s",presultado);
    }
 
}
void binario_a_decimal()
{
    char *bin=calloc(8,sizeof(char));
    printf("Dame un numero en binario (hasta 64 bits):");
    scanf("%s",bin);
    uint64_t res=0;
    int i=0;
    char *p_f_bin=bin+strlen(bin)-1;
    while(p_f_bin!=bin-1)
    {
        if((*(p_f_bin)-48)==1)
        {
            res+=pow_uint64(2,i);
        }
        ++i;
        --p_f_bin;
    }
    printf("Su numero en decimal es: %I64u",res);
}
void invertir_cadena(char *cadena)
{
    char *p_f_cadena=cadena+strlen(cadena)-1;
    char save=0;
    for(int i = 0; cadena+i<=p_f_cadena; ++i)
    {
        save=*(cadena+i);
        *(cadena+i)=*p_f_cadena;
 
        *p_f_cadena=save;
        --p_f_cadena;
    }
}
uint64_t pow_uint64(uint64_t base, uint32_t exp)
{
		uint64_t ret = 1;
		for (uint32_t i = 0; i < exp; ++i)
			ret *= base;
		return ret;
}
 

Te paso el proyecto , a ver que pasa. http://www.mediafire.com/?ie3oiepblpndb32

Mmmmm que raro , prueba a poner la extensión del archivo de cabecera como .h en vez de como .hpp a ver si va a ser eso.