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

    // 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.

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.

#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é.

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.

#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;
}