No, no estás equivocado, y no tiene apenas gravedad. Pero un fallo de ese estilo en otros parámetros si provoca esos XSS

Si quieres pasar por referencia en C++, es tan simple como:

void sprite::acarga_imagen(char* name,int & n){

De esta forma, pasas n por referencia. Fin del problema


Por otro lado, lo de sprintf, si, me refería a eso, PERO falla una cosa, sprintf si el número es menor que 10, no te va a imprimir 09 o 08, por tanto, no tienes dos carácteres en la cadena (entendiendo estos dos carácteres como representables (numeros, letras), y posiblemente tengas el final de cadena). Entonces, eso deberás gestionarlo tu (si num <10 haces de una forma, sino, de otra)

Tu opción más "rentable" pasa por imprimir con sprintf o usar un stringstream para obtener el entero en una cadena, y entonces seleccionar los dos primeros carácteres.

aquí se discutió el tema hace poco.

http://foro.elhacker.net/programacion_cc/referencia_de_un_char_en_una_funcionakai_pasate_por_favor_que_modificadoxd-t322721.0.html

Por otro lado, si no quieres usar eso, tu otra opción es primero obtener el módulo 10 del número (último dígito) y luego dividir entre 10 mientras el número sea mayor que 0. Obviamente, tendrías que ir guardando en algún lado el último y penúltimo resultado del módulo.

consejo? lo primero es menos trabajo.

drvy | BSM, puede no parecer serio, pero fallos "tontos" como estos, muchas veces terminan en XSS BRUTALES.

Si, esto sería un pequeño shell de una práctica de la facultad donde se utiliza esto:

Esto crea tantos hijos como ordenes hay, y luego cada hijo hace hace un exec para cambiarse por el programa que realmente nos interesa poner en su lugar.

Esto se plantea como que el shell crea 2 hijos cuando tu le pides ejecutar "ls -la | grep root"

el primer hijo se hace un exec a "ls -la" y el segundo a "grep root"

	for(i=0;i<nordenes;i++){
		forkpid=fork();
		if(forkpid==0){
			redirigir_entrada(i);
			redirigir_salida(i);
			cerrar_fd();
			if(-1==execvp(ordenes[i],args[i]))
				exit(-1);
		}
		else if(forkpid==-1){
			return ERROR;
		}
		else{
 
		}
	}
	cerrar_fd();

Pero antes de ese código se preparan los canales de esta forma:
cmdfd es una estructura que contiene dos enteros, infd y outfd.

for(i=0;i<ncmd-1;i++){
        pipe(fds);
        cmdfd[i].outfd=fds[1];
        cmdfd[i+1].infd=fds[0];
    }

Para las órdenes que haya, se crean n-1 tuberias.

(revisa la referencia de pipe y dup2)

y redirigir la entrada o salida sería esto:

int redirigir_entrada(int i){
    if(cmdfd[i].infd!=0){ //evitar redirigir la entrada estándar sobre si misma, perdida de tiempo.
        if(-1!=dup2(cmdfd[i].infd,0))
            return OK;
        return ERROR;
        }
    return OK;
}
 
int redirigir_salida(int i){
	if(cmdfd[i].outfd!=1){ //evitar redirigir la salida estándar sobre si misma, perdida de tiempo
		if(-1!=dup2(cmdfd[i].outfd,1))
			return OK;
		return ERROR;
	}
    return OK;
}
int cerrar_fd(){
    int i; 
    for(i=3;i<=nds+2;i++){ //nds +2 es el numero del último descriptor de fichero activo.
        close(i);
        }
    return OK;
}
 

Posiblemente encuentres por ahí un código más claro, pero lo básico es:

Preparar canales
Crear hijos
Cerrar canales del padre si no se tiene que comunicar con los hijos
Que los hijos se redirijan las entradas / salidas y cerrar los descriptores sobrantes
A correr.

EDIT: editados los comentarios del código.

Si estás en un sistema tipo Unix, utilizar tuberías puede ser una opción.

El procedimiento sería crear las tuberías desde el padre, crear los hijos, cerrar las tuberías en el padre y como los hijos heredan los descriptores de ficheros del padre, que estos  utilicen como entrada y/o salida las tuberías. que el padre tenía abiertas en el momento de crear los hijos.

dup2 y pipe son las funciones usadas para ello.

En un sistema Windows no sabría decirte.

En una lista enlazada no puedes hacer eso, bueno, si lo puedes hacer, pero no en los términos de obtener el resultado esperado.

Si lo haces sobre un array, te dará el tamaño de dicho array porque está situado en zonas de memoria contiguas.

PERO con listas enlazadas, esto no se cumple, ya que la inserción de cada nodo pudo haber sido contigua o no pero no cuentan como la misma estructura (array), y por tanto, no están en zonas contiguas de memoria.

Necesitas de alguna forma guardar el tamaño de tu lista. Alguna variable que incrementa cada vez que añades un nodo.

PD: array = tipo[]

[Zero]
Si sabes que tu lectura va a ser siempre un entero y un salto de linea, creo que esto debería dar la talla.

scanf("%d\n"&entero);

En principio debería funcionar, si no me equivoco en algo.

Para lectura de dos enteros, (entero espacio entero salto de linea)

scanf("%d %d\n"&entero)

Esto es debido a que scanf se utiliza para "scan with format".

Como comentario curioso, en una práctica teníamos que leer algo de este estilo de un fichero:

r tabulador X tabulador (45,64) espacio (78,95) salto de linea

infernal, no?
\t es el tabulador

fscanf(fichero, "%c\t%c\t(%d,%d) (%d,%d)\n",&char1,&char2,&int1,&int2,&int3,&int4)

y problema solucionado xD

Chillinfart, me da que no has entendido el cambio en el ciclo de desarrollo. Los cambios de versión "menores" que incluían parches, y algunas novedades ahora son similares a los 3.x de firefox 3. Salvo que al estilo chrome, le van a cambiar el número a la versión, no a la subversión.

En principio, el último "gran release" de firefox era el salto de 3 a 4, es decir, la última vez que en principio va a haber semejante cambio. Probablemente un cambio similar sólo se notará si miras, pongamos firefox 4 con firefox 7 a finales de año o firefox 8 del año que viene o asi.

Mi opinión? Aprendes C a secas. De esa forma NO te dsitraes con la programación orientada a objetos.

Una vez tienes un cierto dominio de C, subes a C++, es C ampliado, y aprendes programación orientada a objetos. No recomiendo empezar directamente con un lenguaje de programación orientada a objetos, porque si estás aprendiendo de primeras a programar, complica las cosas.

Por tanto, después de C++, ya verás que es lo que más te trae, y el resto de lenguajes en principio simplemente serán cosa de mirar la sintaxis para ver como se hace esto o aquello, pero no aprender a programar, sino aprender a escribir para ese lenguaje.

¿Por qué lo veo así? Antes de entrar a la facultad vi por mi cuenta C, en el instituto. Una de las asignaturas de 1o de la carrera era también programación en C, y en 2o se pasa a C++ y se introduce la POO. C puede costar al principio, pero cual es el resultado de seguir ese camino?

Para mi, prácticamente java y python es cuestión de mirarme la sintaxis para cuando quiera mirármelos más a fondo de lo breve que los conozco. Lo mismo para cualquier otro lenguaje. C me ha creado una forma de expresar mis ideas en código, C++ me dio otro método para lo mismo pero orientado a objetos, y como ya dije, ahora simplemente es para el lenguaje X revisar la sintaxis para ver como se trasladan lo mismo. Pero no necesito aprender a programar cada vez. De la misma forma que tu no necesitas volver a aprender a hablar como cuando lo hiciste de niño, ya tienes una concepción del mundo y cuando aprendes un idioma lo único que haces es aprender a expresar dicha visión a través de las palabras del otro idioma.