si "paramsToWrite" es un vector de elementos de tipo "struct configParam", queda claro que para acceder a cada elemento de tipo "configParam" necesitas usar el operador de indice:

"paramsToWrite[contador];"

Luego, para acceder a cada uno de los miembros de "configParam" tienes que usar el operador adeucado y el nombre del miembro con el que quieres interactuar. En el caso del operador se distinguen dos casos:

* Si el acceso es por valor, se usa el operador '.'
* Si el acceso es mediante punteros, se usa el operador '->'

Entonces, dado que "paramsToWrite" te da acceso a un elemento de tipo "configParam" por valor, el acceso quedaría tal que:

// Para escribir
strcpy( paramsToWrite[contador].clave, "aqui la clave" );
 
// Para leer
char* cad;
strcpy( cad, paramsToWrite[contador].clave );

PD.: no te olvides de incrementar "contador" en cada iteración.

Un saludo.

Si por "usuario" quieres decir "programador" te tengo que corregir. No es invisible al programador.

Para que tu programa pueda mostrar una interfaz gráfica necesitas que tu código se conecte con la API correspondiente del sistema operativo que se encarga de gestionar la interfaz de usuario del sistema operativo. Lo que sucede es que normalmente no trabajas directamente sobre la API del sistema operativo, sino que haces uso de una librería que alguien se ha molestado en programar, y que te permite crear interfaces gráficas de una forma más sencilla.

En el caso de Delphi, la librería gráfica es la VCL (Visual Component Library). Además, tienes la "suerte" de que esta librería la proporciona Borland por defecto junto con el IDE, pero aunque no tengas que preocuparte por cómo funciona la clase "Button" de la VCL, has de saber que siempre vas a poder crear tus propios controles gráficos... y para poder hacer eso tienes que conocer cómo funciona esta librería.

En el caso de VisualBasic, la librería gráfica es la MFC (Microsoft Foundation Class). Tienes la "suerte" de que esta librería, al igual que la de Delphi, la proporciona Microsoft por defecto junto con su IDE.

En cualquier caso, has de saber que siempre tienes la opción de trabajar directamente con la API... al fin y al cabo cualquier componente gráfico se va a acabar apoyando antes o después en dicha API.

¿Por qué estoy tan seguro de que todo pasa por la API del sistema operativo? Muy sencillo. Si cada aplicación crease su propio gestor de ventanas sería imposible que pudieses visualizar varias aplicaciones a la vez en la pantalla del ordenador. Para que esto sea posible es necesario que exista un gestor común que se encargue de decidir qué ventana está encima de otra, con qué control está interactuando el usuario en cada momento, a qué control le llega el "foco" cuando el usuario manipula el ratón, etc.

En cuanto a cómo lo hacen con el bucle de mensajes... a ver, normalmente cuando se crea una aplicación con interfaz gráfica, se especifica una función que será la encargada de recibir todos los mensajes por parte del SO. En esta función se encapsula una secuencia de "if" para capturar todos los mensajes importantes para la aplicación. Cuando se recibe un mensaje que es reconcido por la aplicación, el código de esta función acaba llamando a un método concreto de la aplicación para que ese mensaje sea correctamente procesado.

Un ejemplo. Tienes una aplicación con dos botones (A y B), y quieres que al presionar el botón A aparezca un texto en pantalla. Entonces en el bucle de mensajes tienes que "escuchar" un mensaje de tipo "BOTON_PRESIONADO"... además, tendrás que asegurarte de que el botón presionado sea el A. Si todo lo anterior se cumple entonces el bucle de mensajes tiene que llamar a la función BotonAPresionado. Esta última función será la que muestre el mensaje por pantalla y, tras esto, la ejecución volverá al bucle de mensajes a la espera del siguiente mensaje.

#define BOTON_PRESIONADO = 0x01
 
#define A = 0x01
#define B = 0x02
 
void bucleMensajes( int mensaje, int control )
{
  if( mensaje == BOTON_PRESIONADO && control == A )
    BotonAPresionado( );
}
 
void BotonAPresionado( )
{
  // Mostrar mensaje en pantalla
}

El problema de trabajar a tan bajo nivel es que mantener ordenado la función del bucle de mensajes puede ser bastante complicado... las librerías gráficas te abstraen de esta parte, ya que ellas solas son capaces de configurar el bucle de mensajes en base a la configuración que tu ventana.

void FindReplace(char s[], char e1, char e2){
  return s;
}

Si la función es "void" no puede tener "return s". Si necesitas devolver "s" entonces la función tienes que cambiar "void" por el tipo de retorno, en este caso char*.

Por otro lado,

for(i=0;s[i]!=0;i++);

Fíjate que ese "for" termina con ";"... ese bucle no va a hacer absolutamente nada y, en consecuencia, el if que le sigue va a sufrir las siguientes consecuencias:

• Solo se va a ejecutar una vez
• s[ i ] va a apuntar SIEMPRE al final de la cadena (por el efecto del bucle for)

Y, bueno, intenta evitar el uso de variables globales.

Un saludo.

Bienvenido al foro.

Lo primero, el código lo tienes que decorar con las etiquetas GeSHi. Son las normas del foro y, además, mejora su legibilidad.

Un consejo: en C++ no hace falta usar typedef para declarar las estructuras o las clases. Las dos líneas de código siguientes son equivalentes en C++:

typedef struct {int padron; string nombre;}datos;
struct datos{int padron; string nombre;};

Vamos con tu error. A ver, typedef se usa para definir un alias... si el alias lo defines en un archivo de cabecera, todos los ficheros que incluyan dicha cabecera tendrán acceso a dicho alias.

En tu caso el problema es que estás definiendo dos veces el alias "datos"... uno a nivel global y otro dentro del main. El conflicto que esto genera se basa en que el alias del main únicamente tiene validez dentro del main... y no solo eso... no solo su ámbito es diferente, también lo es su "nombre interno" de cara al compilador C++:


es básicamente lo que te está diciendo el mensaje de error... no sabe cómo convertir main::datos a ::datos.

La solución es tan simple como quitar el typedef del main.

Un saludo.

Si yo veo que una posición de memoria tiene el valor 0x144a no tengo forma de saber si ese valor se corresponde con una dirección de memoria apuntada o con un valor.

En cualquier caso, ivancea96 te ha comentado una forma en la que puedes modificar la memoria de programas externos.

Un saludo

Lo que intentas hacer se llama permutación.

Si estás en C++ puedes usar next_permutation

Para hacer permutaciones en C tienes que currarte el algoritmo. Puedes buscar en Internet... puedes encontrar algo de código que te ayude en la tarea.

Un saludo.

si "p" es un puntero, con "p" accedes a la dirección de memoria apuntada y con "*p" accedes al contenido de la memoria apuntada. Un ejemplo:

int variable1 = 5;
int variable2 = 10;
 
int* puntero; // ahora mismo no apunta a nada válido
puntero = &variable1; // puntero apunta a "variable1"
printf( "0x%x -> %d\n", puntero, *puntero );
 
// Cambiamos el valor "apuntado"
*puntero = 23;
printf( "0x%x -> %d\n", puntero, *puntero );
 
puntero = &variable2; // puntero apunta a "variable2"
 
printf( "0x%x -> %d\n", puntero, *puntero );
 
// Cambiamos el valor "apuntado"
*puntero = 71;
printf( "0x%x -> %d\n", puntero, *puntero );
 
printf( "variable1: %d\n", variable1 );
printf( "variable2: %d\n", variable2 );

aunque esté respondida la respuesta, matizo.

El tema del if es que toda la condición ha de estar encerrada por un paréntesis... pero eso no impide que puedas usar paréntesis internos para organizar el código correctamente. Lo siguiente también sería válido:

If((grade=='a') || (grade=='A'))

Un saludo.

¿Qué tal algo así?

#include <iostream>
#include <set>
#include <vector>
#include <conio.h>
#include <windows.h>
 
class MenuItem
{
  public:
 
    MenuItem( char tecla,
              const std::string& texto,
              unsigned char backColor,
              unsigned char foreColor )
      : _tecla( tecla ),
        _texto( texto ),
        _backColor( backColor ),
        _foreColor( foreColor )
    { }
 
    ~MenuItem( )
    { }
 
    char Tecla( ) const
    { return _tecla; }
 
    std::string Texto( ) const
    { return _texto; }
 
    unsigned char BackColor( ) const
    { return _backColor; }
 
    unsigned char ForeColor( ) const
    { return _foreColor; }
 
  private:
 
    char _tecla;
    std::string _texto;
    unsigned char _backColor;
    unsigned char _foreColor;
};
 
void SetBG(unsigned char ForgC, unsigned char BackC);
void menu();
char mostrarMenu( const std::vector< MenuItem >& items );
 
main ()
{
 while (1)
 {
   menu();
 }
}
 
//Define la función de menú
void menu()
{
  std::vector< MenuItem > items;
  items.push_back( MenuItem( '1', "Opción 1", 14, 0 ) );
  items.push_back( MenuItem( '2', "Opción 2", 0, 5 ) );
  items.push_back( MenuItem( 'a', "Opción 3", 4, 7 ) );
 
  char opcion = mostrarMenu( items );
 
  switch( opcion )
  {
    case '1':
      system( "cls" );
      std::cout << "Ejecutando 1" << std::endl;
      break;
    case '2':
      system( "cls" );
      std::cout << "Ejecutando 2" << std::endl;
      break;
    case 'a':
      system( "cls" );
      std::cout << "Ejecutando 'a'" << std::endl;
      break;
 
    default:
      break;
  }
 
  getch( );
}
 
char mostrarMenu( const std::vector< MenuItem >& items )
{
  char to_return;
  std::set< char > validAnswer;
 
  do
  {
    system( "cls" );
    std::cout << "   MENU" << std::endl
              << "===================" << std::endl;
    for( auto& item : items )
    {
      SetBG( item.ForeColor( ), item.BackColor( ) );
      std::cout << "  " << item.Tecla( ) << ". " << item.Texto( ) << std::endl;
      validAnswer.insert( item.Tecla( ) );
    }
    SetBG(15,0);
    std::cin >> to_return;
 
  } while( validAnswer.count( to_return ) == 0 );
 
  return to_return;
}
 
void SetBG(unsigned char ForgC, unsigned char BackC)
{
  WORD wColor = ((BackC & 0x0F) << 4) + (ForgC & 0x0F);
  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), wColor);
}

Se podría conseguir un código más claro si se "mapeasen" los colores:

enum Color : unsigned char
{
  Black,
  DarkBlue,
  DrakGreen,
  DarkAqua,
  DarkRed,
  DarkPurple,
  DarkYellow,
  Silver,
  Gray,
  Blue,
  Green,
  Aqua,
  Red,
  Purple,
  Yellow,
  White
};
 
// ...
 
class MenuItem
{
  public:
 
    MenuItem( char tecla,
              const std::string& texto,
              Color backColor,
              Color foreColor );
 
    Color BackColor( ) const;
 
    Color ForeColor( ) const;
 
  private:
 
    Color _backColor;
    Color _foreColor;
};
 
// ...
 
  items.push_back( MenuItem( '1', "Opción 1", Black, Red ) );
  items.push_back( MenuItem( '2', "Opción 2", Black, Blue ) );
  items.push_back( MenuItem( 'a', "Opción 3", Silver, Purple ) );

¿No prefieres mejor un enlace a un manual de C?

En serio, para que eso funcione necesitas un nivel mínimo que, a raiz de tus preguntas, no tienes.

Aun así:

int main( )
{
  int a = 0, b = 0;
  int* puntero = &a;
  *puntero = 20;
 
  puntero = &b;
  *puntero = 30;
 
  printf( "%d %d", a, b ); // Imprime "20 30"
}