Mensajes

Creo qué no me he explicado bien. Lo qué trato de hacer es pasar la dirección de
a[0], a[1], a[2], a[3]. Ya qué cada uno tiene su dirección de memoria, esas direcciones son las que intento pasar. Qué a la vez son punteros que contienen almacenadas otras direcciones.

Hehe amchacon ya esta listo, no me había fijado en el segundo código que me pasaste.

Hola prueba de esta forma, te imprimira cada direccion de las variables apuntada
por el vector de punteros creo que es eso lo que buscas.

Código (cpp) [Seleccionar] Expandir

#include <iostream>

using namespace std;

void muestraD_arreglo(int* pArreglo[])
{
    cout << (int)pArreglo[0] << endl; // Si quieres los valores seria *pArreglo[0]
    cout << (int)pArreglo[1] << endl;
    cout << (int)pArreglo[2] << endl;
    cout << (int)pArreglo[3] << endl;
}

int main()
{
   int b = 15 , c = 30 , d = 29 , e = 76 ;
   int *a[4];

   a[0] = &b;
   a[1] = &c;
   a[2] = &d;
   a[3] = &e;

   muestraD_arreglo(a);

   cin.get();
   return 0;
}


Saludos  

Hehe gracias, pero ya había intentado eso. Lo qué intento hacer es, no pasar la direcciones de memoria que almacena el arreglo, si no, la dirección de memoria de cada arreglo como tal. En pocas palabras un doble puntero.

Un doble puntero "simple" se pasaría así:

Código (cpp) [Seleccionar] Expandir


int main()
{
int a = 20;
int *b = &a;

pPuntero(&b);

}

//Y la función tendria esta forma:
void pPuntero(int **p)
{
cout << p << endl; //Muestra dirección del puntero 'b'.
cout << *p << endl; //Muestra dirección de la variable a la que apunta el primer puntero 'b'.
cout << **p << endl; //Muestra el valor de la variable a la que apunta el primer puntero 'b'.
}


Ahora estoy tratando de hacer eso mismo pero con un arreglo.

Necesito ayuda con este código qué para uds seguro es algo sencillo de resolverme.

Este es el código:

Código (cpp) [Seleccionar] Expandir


# include <iostream>
using namespace std;

void muestraD_arreglo(int **pArreglo[])
{
     cout << pArreglo[0] << endl;
     cout << pArreglo[1] << endl;
     cout << pArreglo[2] << endl;
     cout << pArreglo[3] << endl;
}
int main()
{
    int b = 15 , c = 30 , d = 29 , e = 76 ;
   
    int *a[4];
   
    a[0] = &b;
    a[1] = &c;
    a[2] = &d;
    a[3] = &e;
   
    muestraD_arreglo(&a);   

system("pause>nul");
return 0;     

}


Lo qué intento hacer es pasar la dirección de memoria de un arreglo que a la vez es un puntero.

Bueno tengo una duda sobre las clases anidadas, mi duda es la siguiente:

Si creo una clase dentro de otra clase, los datos miembros de la clase interna también le pertenecen a la clase externa.?

Si yo creo una función miembro constante en la clase externa, puedo modificar las variables miembro de la clase interna o no?

Otra cosa porqué si yo al declarar el nombre de una clase en la función principal, digamos que es const las demas funciones tienen que ser const porqué si no da error, a que se debe esto? Pude concluir que es para no modificar los valores que le pase o simplemente le digo al compilador que esa variable solamente trabajara con las funciones const. Un ejemplo claro seria este:

Código [Seleccionar] Expandir


#include <iostream>
using std::cout;
using std::endl;
class Prueba
{
private:
 int x;
public:
 Prueba(int x = 0){escribe(x);}//constructor
 int obtiene() const{return x;}//obtiene es const
 int obtiene2(){return x;}
 void escribe(int y){x = y;}
 // void escribe(int y) const{x = y;}
};
int main()
{
 Prueba num1;
 const Prueba num2(25);
 cout << num2.obtiene();
 // cout << num2.obtiene2(); //error obtiene2 no es const.
 num1 = num2;
 cout << num1.obtiene2(); //permitido num1 no es const.
}


Para resumir la tercera pregunta que dudo haya quedado clara xD Ya como les enseñe este código(No recuerdo de donde lo saque creo que de un blog >__<) En fín, le estoy diciendo al compilador que 'num2' trabajara únicamete con las funciones miembro constantes de la clase Prueba?

Bueno tengo una duda hay una parte del código (De los tuto que estoy siguiendo):

Código [Seleccionar] Expandir

e.handle = false
e.handle = true

yo lo que quiero saber es que significa la variable 'e', 'sender', y 'handle'.
Por lo que tengo entendido la variable 'e', es la que almacena el cambio del textbox y el 'handle' es algo como hacer y no hacer. El sender si no tengo ni minima idea.

Alguien que me aclare esto por favor.

- Un archivo de cabecera el cual, solo contiene los prototipos de las funciones. Este archivo seria la interfaz.
- Un archivo de codigo fuente que solo contiene las definiciones de las funciones. Este seria la implementacion.
- Y otro archivo de codigo fuente en el que se encuentra nuestra funcion main().

Exacto a esa última parte me refiero, pero entonces si incluimos la cabecera, y la cabecera tiene de forma separada la definicion en otro archivo de código fuente (Qué no es el main), el le da el cuerpo a esas funciones de la cabecera y luego con añadir la cabecera basta? Porqué ya el otro archivo de código fuente le dio el cuerpo no?. Espero haberme explicado.

Hola bueno, es qué tengo una duda sobre este tema, mi profesor no explica muy bien que digamos. >__< Y acá me ayudan todo el tiempo xD

Ok bueno, mi duda es la siguiente:

Un archivo de cabecera contiene las declaraciones de un archivo de código fuente. Entonces el archivo de código fuente es el que le da el cuerpo a esas declaraciones. Pero entonces al ir al main se añade la cabecera y no el código fuente que le da cuerpo a las funciones de esa cabecera.

Alguien que me explique claramente esto.

Porqué yo por mi parte pienso que seria bueno añadir el código fuente que le da el cuerpo a esas declaraciones de la cabecera, ya qué bueno es la que tiene el cuerpo de las declaraciones. >__< Pero claro estoy para aprender.

Y sí también se que se puede añadir el archivo de código fuente pero ese no es el caso.

1 byte son 8 bits. Ergo 2 bytes son 16 bits. Cada bit tiene dos estados: Activo (1) o apagado (0).

Cojamos un unsigned, pones un 1. Los bits estarán:

0000000000000001

Si pones un 2:

0000000000000010

Si pones un 3:

0000000000000011

Basicamente consiste en escribir en binario el número. Si tuvieramos signo sería igual pero cogiendo el bit de la izquierda para indicar el signo (0 sería uno 1 sería el otro).

Venga tio gracias, pero ahora otra cosa si una variablente entera reserva 2 bytes eso quiere decir que esta reservando 2 espacios en memoria no? Porqué segun entiendo 1 byte equivale a 1 espacio en memoria. Entonces si imprimo en pantalla la dirección de la variable me muestra la dirección del primer byte?

Espero haberme explicado
De otra manera si al yo declarar una variable entera se reserva 2 bytes entonces esos 2 bytes son guardados en cierta dirección de memoria??

Y al yo imprimir la dirrecion me imprime dicha direccion?

Bueno es que quiero saber como trabajan las variables dentro de la memoria,

lo único que encontre fue esto, ejemplo:

int (16 bits ):  Utiliza generalmente 2 bytes de memoria, valores: de -32 768 a 32 767.

int (32 bits): Utiliza generalmente 4 bytes de memoria, valores: de -2 147 483 648 a 2 147 483 647.

Esto quiere decir que en los byte por ejemplo int(16 bits) si yo coloca un valor que llegue casi hasta el maximo, simplemente esta ocupando 2 bytes de memoria? o ocupan mas?

Tengo entendido que un byte es  como una celda, y en esa celda se almacenan los valores.

"Sub" es el identificador de procedimiento, así solito es público (es lo mismo que "public sub"), o sea que puede ser usado desde módulos externos (del mismo proyecto, obvio)s, si se pone "private", entonces sólo puede usarse en el módulo que se declara.

¡Saludos!

Podrías darme un ejemplo? Osea sí declaro una variable en un procedimiento public lo puedo usar en otro procedimiento public y con private jamas y nunca se puede hacer eso?