Mensajes

la mayoría que dice que va a empezar por C termina haciendo una mezcla de C++ pero sin objetos. Osea, cuando descubras que C++ te permite compilar C y te da algunas comodidades como declarar variables en el medio del código, el tipo bool, y otras flexibilidades... si realmente empezás con C usa archivos .c , pero si usás archivos .cpp entonces vas a estar empezando con C++ sin objetos. mandate con C++ directamente XD y cuando sepas manejarlo regularmente empezá con objetos.

[queue]

yo había hecho algo hace unos meses pero sin tener bien los conceptos de pilas  y colas, hoy por hoy ya he usado pilas y colas en c++. Esto es un .h de un proyecto que tenía no se si te sirve realmente, está en c
también en la librería standard hay soporte para pilas y colas,

queue
stack

Código [Seleccionar] Expandir


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// UTN FRGP TSP
// BS
// EMAIL: david_bs@live.com
// 09-09-2011

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef _PILA_H_
#define _PILA_H_

//

char pila[256];

//

const char* P_Pila()
{
return pila;
}

void P_Constructor(int cantidad_de_elementos)
{
memset(pila, 'X', sizeof(char)*(cantidad_de_elementos));
memset(&pila[cantidad_de_elementos], 0, sizeof(char));
}

void P_Destructor()
{
}

void P_Inicializar(const char* buffer)
{
int len=strlen(buffer);
char backup[256];

int index;
for(index=0;index<len;index++)
backup[index]=buffer[index];
backup[len]=0;
strcpy(pila, backup);
}

void P_Push(int len, char elemento)
{
int index;
for(index=0; index<len;index++){
if(pila[index]=='X'){
pila[index]=elemento;
break;
}
}
}

void P_Pop(int len)
{
int index;
for(index=(len-1); index>=0;index--){
if(pila[index]!='X'){

V_Push(len,pila[index]);
pila[index]='X';
break;
}
}
}

void P_Quitar(int pos_elemento)
{
pila[pos_elemento]='X';
}

int P_Tope(int len)
{
int index;
for(index=0; index<len;index++){
if(pila[index]=='X'){
return index;
}
}
return len-1;
}

int P_Elementos(int len)
{
int elementos=0;
int index;
for(index=0; index<len;index++){
if(pila[index]!='X'){
elementos++;
}
}
return elementos;
}

/*void P_Mostrar(int len)
{
int c=0;
int index;
//int len=strlen(pila);
for(index=0;index<len;index++){
if(pila[index] != 'X'){
printf("%c", pila[index]);
c++;
}
}

if(c==0) printf("vacia\n");
printf("\n");
}*/

//

#endif


[realloc]

si la cantidad de ingresos se da por teclado vez x vez, por ahí podés usar realloc para redimensionar el bloque de memoria inicial. distinto si tu programa pregunta cuantas palabras desea ingresar y vos le ponés 5 suponete y entonces hacés un malloc para 5.

realloc

si te sirve..
http://foro.elhacker.net/programacion_cc/ejemplo_de_ordenamientos_basicos-t358139.0.html

si el problema es que no se sobrepase la longitud entonces usa cin.getline y pasale la cantidad de caracteres máxima.

sino usá un char* con malloc, osea memoria dinámica


sino usa codeblocks XD que te permite el mecanismo de VLA aunque parece poco profesional eso de declarar un string de 5 y que puedas poner los que quieras  .

[Proyecto]

Hola, hice un programita tonto que utiliza una función recursiva, solamente para mostrar algunos detalles..

El programa se trata de tener un texto que debe ser superior a los 168 caracteres, ya sea en un array o para ser ingresado, luego el texto debe ser manejado por un puntero char* y debe ser examinado por una función recursiva.

con un sólo llamado a la función recursiva en el main, se debe poder obtener ciertos datos del texto.

1) cantidad de letras
2) cantidad de vocales
3) cantidad de consonantes
4) cantidad de espacios

El programa requiere el uso de aritmética de punteros como van a ver en el código.

además esta técnica es dependiente de un vector declarado como 'static' para que no cambie su dirección en memoria y pueda ser accesible durante todo el programa.

dejo el código a continuación..

Este sería el texto contenido en un array

Código [Seleccionar] Expandir


char texto[200] = {


'a','s','d','x','x','x','x','x','x','x',
'x','a','s','d','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x',' ','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x','x',
'a','s','d','x','x','x','x','x','x',0};


Esta es la función recursiva. devuelve un puntero a vector int de 4.
El número 4 hace referencia a los 4 resultados que debemos obtener del texto.

Código [Seleccionar] Expandir


int* arreglo_final_re(char* str, char letra){

static int vec[4]={0};
int estado=0;
if(*str!=NULL){
if(*str==letra) estado=1;
if((*str=='a')||(*str=='e')||(*str=='i')||(*str=='o')||(*str=='u')) estado=2;
if((*str!='a')&&(*str!='e')&&(*str!='i')&&(*str!='o')&&(*str!='u')) estado=3;
if(*str==' ') estado=4;
str++;
for(unsigned int i=1; i<=estado;i++){
if(estado==3&&i==2)continue;
if(estado==4&&(i==2||i==3))continue;
vec[i-1]++;
}

//arreglo_final_re(str,letra);//esto dejaria en la pila varios ret+address los cuales deben popearse luego..
return arreglo_final_re(str,letra);
}

printf("----------------------------------------\n");
printf("cantidad letras: %d\n",vec[0]);
printf("cantidad vocales: %d\n",vec[1]);
printf("cantidad consonantes: %d\n",vec[2]);
printf("cantidad blancos: %d\n",vec[3]);
printf("----------------------------------------\n");
printf("----------------------------------------\n");
printf("Direccion del vector static: %x\n",vec);
printf("----------------------------------------\n");

return &vec[0];

}


Este sería el punto de entrada del programa

Código [Seleccionar] Expandir


int main(){

char* t = texto;
printf("Texto: %s\n",t);
printf("----------------------------------------\n");

int* p =arreglo_final_re(t,'x');
printf("----------------------------------------\n");
printf("Direccion rescatada desde el Main: %x\n",p);
printf("----------------------------------------\n");
printf("Letras: %d\n",*(p+0));
printf("Vocales: %d\n",*(p+1));
printf("Consonantes: %d\n",*(p+2));
printf("Blancos: %d\n",*(p+3));
printf("----------------------------------------\n");

system("pause");
return 0;
}



dejo el proyecto en MSVC++ 6.0 por si lo desean descargar

Proyecto

si eso cuando los dos operandos son una referencia de contenido de memoria, es decir, estás tratando de hacer algo prohibido.


fijate así,

Código [Seleccionar] Expandir


void func(){

DWORD addressx = (DWORD)&ExitProcess;
//DWORD RetFakeSinPrologo;

__asm{

mov edx, RetFakeSinPrologo
mov dword ptr [ebx],edx

mov eax, addressx
RetFakeSinPrologo:
jmp eax;
}
}



es un ejemplo para que veas como se compila..

EDIT
ah y la referencia a ebx debería ser en tu código un puntero por ejemplo DWORD*, por si no sabías.

EDIT 2
y por supuesto exitprocess requiere que se pase un parámetro por lo que deberías usar push+call y no jmp, que se usa para funciones naked y cuando la pila no sufre alteraciones (por el tema de los parámetros)

cherto,
aunque al menos está bien que haya puesto el array con static para que conserve la dirección (no sea redeclarado en cada call) y no ser destruído (liberado) automáticamente por estar en el stack frame de la función2

Visual C++, aunque yo lo uso no por la parte visual. para eso uso visual C#. pero hablando del compilador en sí, cualquier versión de Visual C++ es buena, pero la última siempre tiene todas las mejoras y actualizaciones.

codeblocks está muy bueno como IDE tmb, te permite seleccionar varios compiladores aparte.

claro, los 5 que reservaste son de los cuales podés estar seguro que son tuyos, ahora más a lo largo de esos 5 es memoria la cual puede estar siendo usada para otras cosas. Aparte de los compiladores con el mecanismo de VLA, lo que corresponde es usar sólo esa memoria que reservaste osea 5.

Y tratándose de cadenas siempre reserva +1 de memoria para el cero delimitador.