Adaptar estas variables a C++

[Meta]

Hola:

Quiero pasar estas variables de C# a C++ con Visual studio 2019.

A pesar de mirarlo aquí, me da problemas.
https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Arrays_y_cadenas_de_texto

Código (csharp) [Seleccionar] Expandir

    // Variables.
    static string guardarNombre = ""; // Guardar nombre escrito.
    static int coordenadaX = 0; // Coordenada X del setCursorPisition.
    //static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
    static int index = 0; // Índice.

    // Caracteres de este array.
    static char[] roALFANUMERICO = new char[]
    {
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
        'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
        'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
        'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
        '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
    };

    // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
    static int[] roINDICE_ARRAY = new int[]
    {
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
    };

    // Palabras del array para imprimir en pantalla.
    static string[] roTEXTO = new string[]{ "ATRÁS", "GUARDAR" };

Vamos, que me lo acepte C++ nativo o win32.

Saludos.

[EdePC]

Saludos,

- En mi Visual C++ 2008 no tengo problemas con lo siguiente:

Código (cpp) [Seleccionar] Expandir

#include "stdafx.h"
#include <iostream>
#include <string>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    // Variables.
    string guardarNombre = ""; // Guardar nombre escrito.
    static int coordenadaX = 0; // Coordenada X del setCursorPisition.
    //static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
    static int index = 0; // Índice.

    // Caracteres de este array.
    static char roALFANUMERICO[] =
    {
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
        'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
        'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
        'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
        '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
    };

    // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
    static int roINDICE_ARRAY[] =
    {
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
    };

    // Palabras del array para imprimir en pantalla.
    static string roTEXTO[] = { "ATRÁS", "GUARDAR" };

cout << guardarNombre << endl;
cout << coordenadaX << endl;
cout << index << endl;
for (int i = 0; i < sizeof(roALFANUMERICO)/sizeof(roALFANUMERICO[0]); i++)
cout << roALFANUMERICO[i] << endl;
for (int i = 0; i < sizeof(roINDICE_ARRAY)/sizeof(roINDICE_ARRAY[0]); i++)
cout << roINDICE_ARRAY[i] << endl;
for (int i = 0; i < sizeof(roTEXTO)/sizeof(roTEXTO[0]); i++)
cout << roTEXTO[i] << endl;
getchar();
return 0;
}



[Meta]

Muchísimas gracias. Funciona a la primera.

No se el motivo, en C# no me deja ponerlo valores constantes con "const", me aconseja ponerle "readonly".

Diferencia const entre readonly.

Ejemplo tuyo modificado con const en C++ 2019.

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <string>
#include <windows.h> // Para mostrar texto en el título de la ventana.
#include <stdio.h>   // Cambio color de fondo y letras.

using namespace std;

int main()
{
   // Variables.
   string guardarNombre = ""; // Guardar nombre escrito.
   static int coordenadaX = 0; // Coordenada X del setCursorPisition.
   //static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
   static int index = 0; // Índice.

   // Caracteres de este array.
   static char const ALFANUMERICO[] =
   {
       'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
       'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
       'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
       'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
       '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
   };

   // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
   static int const INDICE_ARRAY[] =
   {
       80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
   };

   // Palabras del array para imprimir en pantalla.
   static string const TEXTO[] = { "ATRÁS", "GUARDAR" };

   // Mostrar caracteres correctamente en pantalla y título de la ventana.
   SetConsoleOutputCP(65001);
   wchar_t titulo[128];
   MultiByteToWideChar(CP_UTF8, 0, "Título de la ventana. Win32 C++ 2019.", -1, titulo, 128);
   SetConsoleTitle(titulo);

   // Tamaño de la pantalla. Se cambia en los dos últimos dígitos.
   SMALL_RECT r = { 0, 0, 49, 9 }; // X = 49, Y = 9.
   SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &r);

   // Cambio color de 8 (gris), color letras 0 (negro).
   system("color 80");

   // mostrar contenido de las variables.
   cout << guardarNombre << endl;
   cout << coordenadaX << endl;
   cout << index << endl;

   for (int i = 0; i < sizeof(ALFANUMERICO) / sizeof(ALFANUMERICO[0]); i++)
   {
       cout << ALFANUMERICO[i] << endl;
   }

   for (int i = 0; i < sizeof(INDICE_ARRAY) / sizeof(INDICE_ARRAY[0]); i++)
   {
       cout << INDICE_ARRAY[i] << endl;
   }

   for (int i = 0; i < sizeof(TEXTO) / sizeof(TEXTO[0]); i++)
   {
       cout << TEXTO[i] << endl;
   }

   // Esperando pulsar Enter para salir.
   cin.get();
   //getchar();
   return 0;
}

Edito:

Gracias por la ayuda. Porque en realidad quiero pasar este código completo de C# a C++ nativo. Esto ya es demasiado tiempo, pero lo haré.

Código (csharp) [Seleccionar] Expandir

using System;
using System.IO;

namespace LCD_nombre_archivo_consola_11
{
   class Program
   {
       // Variables.
       static string guardarNombre = ""; // Guardar nombre escrito.
       static int coordenadaX = 0; // Coordenada X del setCursorPisition.
       static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
       static int index = 0; // Índice.

       // Caracteres de este array.
       static readonly char[] roALFANUMERICO = new char[]
       {
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
        'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
        'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
        'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
        '¿', '?', '(', ')', '[', ']', '{', '}','=', '$','&', '"', ' '
       };

       // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
       static readonly int[] roINDICE_ARRAY = new int[]
       {
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
       };

       // Palabras del array para imprimir en pantalla.
       static readonly string[] roTEXTO = new string[] { "ATRÁS", "GUARDAR" };

       static void Main(string[] args)
       {
           // Título de la pantalla.
           Console.Title = "Cambiar nombre";

           Inicio();
       }

       static void MainMenu()
       {
           Console.Clear(); // Limpiar pantalla.

           Console.SetCursorPosition(0, 0);
           Console.Write("Nombre del relé 1:  ");
           Console.SetCursorPosition(0, 1);

           // Recorre el índice del array, del 0 hasta donde llegue.
           for (int i = 0; i < roINDICE_ARRAY.Length; i++)
           {
               // Imprime los caracteres del array.
               Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
           }

           Console.SetCursorPosition(3, 3);
           Console.Write(roTEXTO[0]); // ATRÁS.
           Console.SetCursorPosition(12, 3);
           Console.Write(roTEXTO[1]); // GUARDAR.
       }

       #region Inico.
       static void Inicio()
       {
           Console.SetWindowSize(20, 5); // Residemensiona pantalla. X = 20, Y = 5.
           Console.BackgroundColor = ConsoleColor.Gray; // Fondo gris.
           Console.ForegroundColor = ConsoleColor.Black; // Letras negras.

           // ¿El archivo Existe?
           if (File.Exists("Archivo.txt"))
           {
               // Sí. Lee el archivo de texto.
               string nombre = File.ReadAllText("Archivo.txt");
               int a, b; // Almacena ídice array.
               for (a = 0; a < nombre.Length; a++)
               {
                   for (b = 0; roALFANUMERICO[b] != nombre[a]; b++)
                   {
                       ;
                   }
                   roINDICE_ARRAY[a] = b; // b indica índice y lo añade al roINDICE_ARRAY.
               }
           }

           // No. El Archivo.txt no existe. El código continúa por aquí.

           MainMenu(); // Dibuja el menú.

           while (true)
           {
               Console.CursorVisible = true; // Cursor invisible.
               index = 0;

               // Si se cumple estas condiciones, Enter, flecha izquierda, flecha derecha
               if ((tecla == ConsoleKey.Enter) || (tecla == ConsoleKey.RightArrow) || (tecla == ConsoleKey.LeftArrow))
               {
                   MainMenu(); // Dibuja el menú.
               }

               // Posiciona cursor.
               Console.SetCursorPosition(coordenadaX, 1);

               // Almacena en la variable tecla, la tecla pulsada.
               tecla = Console.ReadKey(true).Key;

               // Si coincide una tecla pulsada.
               switch (tecla)
               {
                   case ConsoleKey.RightArrow: // Flecha derecha detectada.
                       // ¿CoordenadaX menor que 15?
                       if (coordenadaX < 15)
                       {
                           coordenadaX++; // Sí. Añada + 1 en la coordenadaX.
                       }
                       // No. Sale de aquí.
                       break;

                   case ConsoleKey.LeftArrow: // Flecha izquierda detectada.
                       // ¿coordenadaX es mayor que 0?
                       if (coordenadaX > 0)
                       {
                           coordenadaX--; // Sí. Decremente o quita -1.
                       }
                       // No. Sale de aquí.
                       break;

                   case ConsoleKey.UpArrow: // Flecha arriba.
                       roINDICE_ARRAY[coordenadaX]++; // En el índice del array añade + en coordenadaX.
                       // ¿El índice del array es mayor o igual que el arra Alfanumérico?
                       if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
                       {
                           roINDICE_ARRAY[coordenadaX] = 0; // Sí. Deja en 0 la coordenada del índice del array.
                       }
                       Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                       break;

                   case ConsoleKey.DownArrow: // Flecha abajo detectado.
                       roINDICE_ARRAY[coordenadaX]--; // Decrementa a -1 el índice del array.
                       // ¿La coordenadaX del indice del array es menor que 0?
                       if (roINDICE_ARRAY[coordenadaX] < 0)
                       {
                           // Sí. Imprimir el valor alfanumérico.
                           roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
                       }
                       Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                       break;

                   case ConsoleKey.Enter: // Detecta la tecla Enter.
                       Console.SetCursorPosition(1, 3); // Posición del cursor.
                       Console.CursorVisible = false; // Se oculta el cursor.
                       Console.Write(">"); // Imprime en pantalla >.

                       // ¿La tecla almacenada es distinto a la tecla Enter?
                       while ((tecla = Console.ReadKey(true).Key) != ConsoleKey.Enter)
                       {
                           // Sí.
                           switch (tecla)
                           {
                               case ConsoleKey.RightArrow:
                                   index = 1;
                                   Console.SetCursorPosition(1, 3);
                                   Console.Write(" ");
                                   Console.SetCursorPosition(10, 3);
                                   Console.Write(">");
                                   break;
                               case ConsoleKey.LeftArrow:
                                   Console.SetCursorPosition(10, 3);
                                   Console.Write(" ");
                                   Console.SetCursorPosition(1, 3);
                                   Console.Write(">");
                                   index = 0;
                                   break;

                               case ConsoleKey.UpArrow:
                                   Inicio();
                                   break;

                               case ConsoleKey.DownArrow:
                                   Inicio();
                                   Console.SetCursorPosition(coordenadaX, 1);
                                   break;
                           }
                       }

                       if (index == 0)
                       {
                           Atras();
                       }
                       if (index == 1)
                       {
                           Guardar();
                       }
                       break;
               }
           }
       }
       #endregion

       static void Atras()
       {
           Console.Clear();
           Console.SetCursorPosition(0, 1);
           Console.Write("HAS PULSADO ATRÁS   ");
           Console.ReadKey(); // Pulse cualquier tecla para salir.
       }

       static void Guardar()
       {
           guardarNombre = "";
           Console.Clear();

           // Lee todo el contennido del array y lo guarda en guardarNombre.
           for (int a = 0; a < roINDICE_ARRAY.Length; a++)
           {
               guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
           }
           Console.SetCursorPosition(0, 2);
           Console.Write(guardarNombre); // Imprime el contenido.

           // Crear Archivo.txt y el contenido de guardarNombre.
           File.WriteAllText("Archivo.txt", guardarNombre);

           Console.SetCursorPosition(0, 1);
           Console.Write("HAS GUARDADO       ");

           // Pulsa otra vez tecla.
           Console.ReadKey();
       }
   }
}

Gracias por todo. Si te animas, mejor. Entonces, lo tienes bien puestos.





EI: Juntando mensajes, otra vez.

Me funciona hasta con Arduino.

Código (cpp) [Seleccionar] Expandir

#include <LiquidCrystal.h>

// Inicializa la librería con sus pines indicados.
LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);

// Pin 10 para saber que es luz de fondo del LCD.
//int LuzFondo = 10;


// Variables.
String guardarNombre = ""; // Guardar nombre escrito.
int coordenadaX = 0; // Coordenada X del setCursorPisition.
int index = 0; // Índice.
// Caracteres de este array.
char const PROGMEM ALFANUMERICO[] =
{
  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
};

// Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
int const PROGMEM INDICE_ARRAY[] =
{
  80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
};

// Palabras del array para imprimir en pantalla.
String const TEXTO[] = { "ATRÁS", "GUARDAR" };

void setup()
{
  // La pantalla es de 16 caracteres y 2 filas.
  lcd.begin(16, 2);
  lcd.print(F("  Probando..."));

  // Baudios del puerto serie.
  Serial.begin(115200);

  // Indicar luz de fondo como salida.
  // pinMode(LuzFondo, OUTPUT);

  Serial.println(guardarNombre);
  Serial.println(coordenadaX);
  Serial.println(index);

  for (byte i = 0; i < 80; i++)
  {
    Serial.println(ALFANUMERICO[i]);
  }

  for (byte j = 0; j < 16; j++)
  {
    Serial.println(INDICE_ARRAY[j]);
  }

  for (byte k = 0; k < 2; k++)
  {
    Serial.println(TEXTO[k]);
  }
}

void loop()
{
  //return 0;
}