Mensajes

en la linea 43 del main, si no nunca sale del bucle y se queda atascado con el CLS y el PAUSE cuando hay un error

¿Que bucle? 

Se nota la diferencia, pero para que sea considerable, he tenido que llegar a 10^10 iteraciones...

Tú código no es correcto para cualquier compilador actual, mi compilador directamente se salta los fors y los ifs porque los considera que son inútiles. La prueba está en que los fors no aparecen en el código ensamblador:

Código (asm) [Seleccionar] Expandir

.file "main.cpp"
.def __main; .scl 2; .type 32; .endef
.section .rdata,"dr"
.LC0:
.ascii "%lu segundos\12\0"
.section .text.startup,"x"
.p2align 4,,15
.globl main
.def main; .scl 2; .type 32; .endef
.seh_proc main
main:
.LFB49:
pushq %rsi
.seh_pushreg %rsi
pushq %rbx
.seh_pushreg %rbx
subq $40, %rsp
.seh_stackalloc 40
.seh_endprologue
call __main
movq __imp__time64(%rip), %rbx
xorl %ecx, %ecx
call *%rbx
xorl %ecx, %ecx
movq %rax, %rsi
call *%rbx
leaq .LC0(%rip), %rcx
movq %rax, %rdx
subq %rsi, %rdx
call printf
xorl %ecx, %ecx
call *%rbx
xorl %ecx, %ecx
movq %rax, %rsi
call *%rbx
leaq .LC0(%rip), %rcx
movq %rax, %rdx
subq %rsi, %rdx
call printf
xorl %eax, %eax
addq $40, %rsp
popq %rbx
popq %rsi
ret
.seh_endproc
.ident "GCC: (rev1, Built by MinGW-builds project) 4.8.1"
.def printf; .scl 2; .type 32; .endef

Lo modifique tal que así:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX 5000000000LLU

int main(int argc, char *argv[])
{
   unsigned long long i;
   unsigned int Contador = 0;
   time_t ini;

   ini = time(NULL);

   for(i = 0 ; i < MAX ; i++)
      Contador += i% 2;

   printf("%lu segundos\n", time(NULL) - ini);

   ini = time(NULL);

   for(i = 0 ; i < MAX ; i++)
       Contador -= i&1;

   printf("%lu segundos\n", time(NULL) - ini);

    printf("%d",Contador);

   return 0;
}

Ahora si que se nota que hace las operaciones, aunque haciendo pruebas. Me di cuenta que ambas operaciones dependían más del factor suerte que de otra cosa (a veces ganaba uno, otra veces ganaba otro y otras veces empataban). Analizando el código ASM:

Código (asm) [Seleccionar] Expandir

.file "main.cpp"
.def __main; .scl 2; .type 32; .endef
.section .rdata,"dr"
.LC0:
.ascii "%lu segundos\12\0"
.LC1:
.ascii "%d\0"
.section .text.startup,"x"
.p2align 4,,15
.globl main
.def main; .scl 2; .type 32; .endef
.seh_proc main
main:
.LFB49:
pushq %rdi
.seh_pushreg %rdi
pushq %rsi
.seh_pushreg %rsi
pushq %rbx
.seh_pushreg %rbx
subq $32, %rsp
.seh_stackalloc 32
.seh_endprologue
xorl %ebx, %ebx
call __main
movq __imp__time64(%rip), %rsi
xorl %ecx, %ecx
call *%rsi
xorl %edx, %edx
movabsq $5000000000, %r8
movq %rax, %rdi
.p2align 4,,10
.L3:
movl %edx, %ecx
addq $1, %rdx
andl $1, %ecx
addl %ecx, %ebx
cmpq %r8, %rdx
jne .L3
xorl %ecx, %ecx
call *%rsi
leaq .LC0(%rip), %rcx
movq %rax, %rdx
subq %rdi, %rdx
call printf
xorl %ecx, %ecx
call *%rsi
xorl %edx, %edx
movabsq $5000000000, %r8
movq %rax, %rdi
.p2align 4,,10
.L5:
movl %edx, %ecx
addq $1, %rdx
andl $1, %ecx
subl %ecx, %ebx
cmpq %r8, %rdx
jne .L5
xorl %ecx, %ecx
call *%rsi
leaq .LC0(%rip), %rcx
movq %rax, %rdx
subq %rdi, %rdx
call printf
leaq .LC1(%rip), %rcx
movl %ebx, %edx
call printf
xorl %eax, %eax
addq $32, %rsp
popq %rbx
popq %rsi
popq %rdi
ret
.seh_endproc
.ident "GCC: (rev1, Built by MinGW-builds project) 4.8.1"
.def printf; .scl 2; .type 32; .endef

Podemos identificar los dos fors aquí:

Código (asm) [Seleccionar] Expandir

.L3:
movl %edx, %ecx
addq $1, %rdx
andl $1, %ecx
addl %ecx, %ebx
cmpq %r8, %rdx
jne .L3

Código (asm) [Seleccionar] Expandir

.L5:
movl %edx, %ecx
addq $1, %rdx
andl $1, %ecx
subl %ecx, %ebx
cmpq %r8, %rdx
jne .L5

Fijate que el compilador lo ha optimizado haciendo las mismas operaciones en los dos casos. Es curioso que incluso desactivando la optimización del compilador, tenemos las mismas operaciones en el for:

Código (asm) [Seleccionar] Expandir

.file "main.cpp"
.def __main; .scl 2; .type 32; .endef
.section .rdata,"dr"
.LC0:
.ascii "%lu segundos\12\0"
.LC1:
.ascii "%d\0"
.text
.globl main
.def main; .scl 2; .type 32; .endef
.seh_proc main
main:
.LFB36:
pushq %rbp
.seh_pushreg %rbp
movq %rsp, %rbp
.seh_setframe %rbp, 0
subq $64, %rsp
.seh_stackalloc 64
.seh_endprologue
movl %ecx, 16(%rbp)
movq %rdx, 24(%rbp)
call __main
movl $0, -12(%rbp)
movl $0, %ecx
call time
movq %rax, -24(%rbp)
movq $0, -8(%rbp)
jmp .L2
.L3:
movq -8(%rbp), %rax
andl $1, %eax
addl %eax, -12(%rbp)
addq $1, -8(%rbp)
.L2:
movabsq $4999999999, %rax
cmpq %rax, -8(%rbp)
jbe .L3
movl $0, %ecx
call time
subq -24(%rbp), %rax
movq %rax, %rdx
leaq .LC0(%rip), %rcx
call printf
movl $0, %ecx
call time
movq %rax, -24(%rbp)
movq $0, -8(%rbp)
jmp .L4
.L5:
movq -8(%rbp), %rax
andl $1, %eax
subl %eax, -12(%rbp)
addq $1, -8(%rbp)
.L4:
movabsq $4999999999, %rax
cmpq %rax, -8(%rbp)
jbe .L5
movl $0, %ecx
call time
subq -24(%rbp), %rax
movq %rax, %rdx
leaq .LC0(%rip), %rcx
call printf
movl -12(%rbp), %eax
movl %eax, %edx
leaq .LC1(%rip), %rcx
call printf
movl $0, %eax
addq $64, %rsp
popq %rbp
ret
.seh_endproc
.ident "GCC: (rev1, Built by MinGW-builds project) 4.8.1"
.def time; .scl 2; .type 32; .endef
.def printf; .scl 2; .type 32; .endef

Código (asm) [Seleccionar] Expandir

jmp .L2
.L3:
movq -8(%rbp), %rax
andl $1, %eax
addl %eax, -12(%rbp)
addq $1, -8(%rbp)
.L2:
movabsq $4999999999, %rax
cmpq %rax, -8(%rbp)
jbe .L3

Código (asm) [Seleccionar] Expandir

jmp .L4
.L5:
movq -8(%rbp), %rax
andl $1, %eax
subl %eax, -12(%rbp)
addq $1, -8(%rbp)
.L4:
movabsq $4999999999, %rax
cmpq %rax, -8(%rbp)
jbe .L5

Ergo, no. No hay diferencia entre % y & en un compilador actual.

wxWidgets es bastante buena, además es software libre (a diferencia de QT).

También puedes usar una librería multimedia (SFML).

No, sigue sin funcionar 

Código (cpp) [Seleccionar] Expandir

template<class T> void swapVariables(T **x, T **y){
T *temp = *y;
*y = *x;
*x = temp;
}
char hello[] = "hello", world[] = "world";
swapVariables(&hello, &world);

No, tienes que declarar unos punteros que apunten al array.

Fijate otra vez en mi ejemplo.

"cambiar los valores de los punteros en vez de las cadenas"?

Me refiero algo tal que así:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <string>

using namespace std;

void Swap(char** a,char** b)
{
    char* Buffer = *a;

    *a = *b;
    *b = Buffer;
}

int main()
{

    char Cadena1[] = "Miauu";
    char Cadena2[] = "Cosita";

    char* Puntero1 = Cadena1;
    char* Puntero2 = Cadena2;

    Swap(&Puntero1,&Puntero2);
    cout<<Puntero1<<endl<<Puntero2;

    cin.get();
    return 0;
}


Yo creo que más eficiente que eso no puede haber... En todo caso se puede hacer una funcion "inline".

[cualquier puntero.]

agregar delete para eliminar la variable temporal (estoy haciendo loops de 1.000.000 iteraciones y cada optimización cuenta). Al no usar new creo que no se puede usar delete, pero si sabéis alguna alternativa, me gustaría verla

¿Variable temporal? Yo no veo que hayas creado ninguna variable en memoria dinámica...

De todas formas, puedes usar delete en cualquier puntero. Ahora, si ese puntero no apunta a memoria reservada dinámicamente dará un error de ejecución.

poder usar la función pasándole char[] en vez de char* sin tener que copiar y pegarla, cambiar el nombre y añadir los corchetes

A la hora de pasar argumentos a una función, char[] y char* son equivalentes (no son más que comodidades sintácticas).

Otra cosa es, que cambies los valores de los punteros en vez de las cadenas

Creo que te has equivocado y has puesto la etiqueta de java (o otro lenguaje, el caso esque ese resaltado sintáctico no me suena).

Si quieres que tu función se sobreescriba en la herencia, debes hacerla "virtual" en la clase base:

Código (cpp) [Seleccionar] Expandir

virtual void metodo();

Ahora sí debería funcionar  

pero si uso una imagen del tamaño de mi pantalla no me funciona el programa

Del tamaño de tu pantalla no, del tamaño de la resolución que pongas.

[O(n)]

Acabo de leerlo. No me parece demasiado interesante. Se centra sobre todo en reducir la cantidad de código máquina generado. No busca reducir el coste computacional del algoritmo. Si el código inicial tiene un orden O(n), el final tendrá el mismo, por lo que desde el punto de vista del algoritmo, no gana nada...

Todas las optimizaciones en ensamblador son lineales

Un amigo está haciendo un trabajo sobre como los compiladores de C (no se si se centra en gcc...) traducen a código máquina y, por lo que me dijo, hay diferencias entre variable++, ++variable,variable = variable + 1 y variable += 1. No se si todas las expresiones anteriores generan distinto código máquina o si alguna es equivalente a alguna de las otras... ¿Sabéis algo mas sobre esto?

Hay una gran diferencia entre variable = variable +1  y usar los operadores de incremento. La primera expresión tienes que mover la variable en un registro, sumarle 1 y devolverlo a la memoria RAM.

La segunda expresión puede hacerse en una sola sentencia con una sentencia de esamblador (creo que era incr).

De todas formas, si activas las optimización del compilador, probablemente esto te lo haga automático.

Hacerlo con estructuras me refiero a  "Struct"  y que la funcion se llame Menu.

Sigo sin entender lo que quieres hacer...