elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: Security Series.XSS. [Cross Site Scripting]


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Adaptar estas variables a C++
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Adaptar estas variables a C++  (Leído 344 veces)
Meta


Desconectado Desconectado

Mensajes: 3.203



Ver Perfil WWW
Adaptar estas variables a C++
« en: 29 Julio 2020, 05:18 »

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
  1.    // Variables.
  2.    static string guardarNombre = ""; // Guardar nombre escrito.
  3.    static int coordenadaX = 0; // Coordenada X del setCursorPisition.
  4.    //static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
  5.    static int index = 0; // Índice.
  6.  
  7.    // Caracteres de este array.
  8.    static char[] roALFANUMERICO = new char[]
  9.    {
  10.        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  11.        'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  12.        'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  13.        'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  14.        '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
  15.    };
  16.  
  17.    // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
  18.    static int[] roINDICE_ARRAY = new int[]
  19.    {
  20.        80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
  21.    };
  22.  
  23.    // Palabras del array para imprimir en pantalla.
  24.    static string[] roTEXTO = new string[]{ "ATRÁS", "GUARDAR" };

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

Saludos.


En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
EdePC
Colaborador
***
Conectado Conectado

Mensajes: 1.332



Ver Perfil
Re: Adaptar estas variables a C++
« Respuesta #1 en: 29 Julio 2020, 06:53 »

Saludos,

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

Código
  1. #include "stdafx.h"
  2. #include <iostream>
  3. #include <string>
  4.  
  5. using namespace std;
  6.  
  7. int _tmain(int argc, _TCHAR* argv[])
  8. {
  9.    // Variables.
  10.    string guardarNombre = ""; // Guardar nombre escrito.
  11.    static int coordenadaX = 0; // Coordenada X del setCursorPisition.
  12.    //static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
  13.    static int index = 0; // Índice.
  14.  
  15.    // Caracteres de este array.
  16.    static char roALFANUMERICO[] =
  17.    {
  18.        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  19.        'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  20.        'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  21.        'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  22.        '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
  23.    };
  24.  
  25.    // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
  26.    static int roINDICE_ARRAY[] =
  27.    {
  28.        80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
  29.    };
  30.  
  31.    // Palabras del array para imprimir en pantalla.
  32.    static string roTEXTO[] = { "ATRÁS", "GUARDAR" };
  33.  
  34. cout << guardarNombre << endl;
  35. cout << coordenadaX << endl;
  36. cout << index << endl;
  37. for (int i = 0; i < sizeof(roALFANUMERICO)/sizeof(roALFANUMERICO[0]); i++)
  38. cout << roALFANUMERICO[i] << endl;
  39. for (int i = 0; i < sizeof(roINDICE_ARRAY)/sizeof(roINDICE_ARRAY[0]); i++)
  40. cout << roINDICE_ARRAY[i] << endl;
  41. for (int i = 0; i < sizeof(roTEXTO)/sizeof(roTEXTO[0]); i++)
  42. cout << roTEXTO[i] << endl;
  43. getchar();
  44. return 0;
  45. }
  46.  
  47.  


En línea

Meta


Desconectado Desconectado

Mensajes: 3.203



Ver Perfil WWW
Re: Adaptar estas variables a C++
« Respuesta #2 en: 29 Julio 2020, 14:43 »

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
  1. #include <iostream>
  2. #include <string>
  3. #include <windows.h> // Para mostrar texto en el título de la ventana.
  4. #include <stdio.h>   // Cambio color de fondo y letras.
  5.  
  6. using namespace std;
  7.  
  8. int main()
  9. {
  10.    // Variables.
  11.    string guardarNombre = ""; // Guardar nombre escrito.
  12.    static int coordenadaX = 0; // Coordenada X del setCursorPisition.
  13.    //static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
  14.    static int index = 0; // Índice.
  15.  
  16.    // Caracteres de este array.
  17.    static char const ALFANUMERICO[] =
  18.    {
  19.        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  20.        'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  21.        'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  22.        'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  23.        '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
  24.    };
  25.  
  26.    // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
  27.    static int const INDICE_ARRAY[] =
  28.    {
  29.        80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
  30.    };
  31.  
  32.    // Palabras del array para imprimir en pantalla.
  33.    static string const TEXTO[] = { "ATRÁS", "GUARDAR" };
  34.  
  35.    // Mostrar caracteres correctamente en pantalla y título de la ventana.
  36.    SetConsoleOutputCP(65001);
  37.    wchar_t titulo[128];
  38.    MultiByteToWideChar(CP_UTF8, 0, "Título de la ventana. Win32 C++ 2019.", -1, titulo, 128);
  39.    SetConsoleTitle(titulo);
  40.  
  41.    // Tamaño de la pantalla. Se cambia en los dos últimos dígitos.
  42.    SMALL_RECT r = { 0, 0, 49, 9 }; // X = 49, Y = 9.
  43.    SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &r);
  44.  
  45.    // Cambio color de 8 (gris), color letras 0 (negro).
  46.    system("color 80");
  47.  
  48.    // mostrar contenido de las variables.
  49.    cout << guardarNombre << endl;
  50.    cout << coordenadaX << endl;
  51.    cout << index << endl;
  52.  
  53.    for (int i = 0; i < sizeof(ALFANUMERICO) / sizeof(ALFANUMERICO[0]); i++)
  54.    {
  55.        cout << ALFANUMERICO[i] << endl;
  56.    }
  57.  
  58.    for (int i = 0; i < sizeof(INDICE_ARRAY) / sizeof(INDICE_ARRAY[0]); i++)
  59.    {
  60.        cout << INDICE_ARRAY[i] << endl;
  61.    }
  62.  
  63.    for (int i = 0; i < sizeof(TEXTO) / sizeof(TEXTO[0]); i++)
  64.    {
  65.        cout << TEXTO[i] << endl;
  66.    }
  67.  
  68.    // Esperando pulsar Enter para salir.
  69.    cin.get();
  70.    //getchar();
  71.    return 0;
  72. }

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
  1. using System;
  2. using System.IO;
  3.  
  4. namespace LCD_nombre_archivo_consola_11
  5. {
  6.    class Program
  7.    {
  8.        // Variables.
  9.        static string guardarNombre = ""; // Guardar nombre escrito.
  10.        static int coordenadaX = 0; // Coordenada X del setCursorPisition.
  11.        static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
  12.        static int index = 0; // Índice.
  13.  
  14.        // Caracteres de este array.
  15.        static readonly char[] roALFANUMERICO = new char[]
  16.        {
  17.         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  18.         'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  19.         'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  20.         'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
  21.         '¿', '?', '(', ')', '[', ']', '{', '}','=', '$','&', '"', ' '
  22.        };
  23.  
  24.        // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
  25.        static readonly int[] roINDICE_ARRAY = new int[]
  26.        {
  27.         80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
  28.        };
  29.  
  30.        // Palabras del array para imprimir en pantalla.
  31.        static readonly string[] roTEXTO = new string[] { "ATRÁS", "GUARDAR" };
  32.  
  33.        static void Main(string[] args)
  34.        {
  35.            // Título de la pantalla.
  36.            Console.Title = "Cambiar nombre";
  37.  
  38.            Inicio();
  39.        }
  40.  
  41.        static void MainMenu()
  42.        {
  43.            Console.Clear(); // Limpiar pantalla.
  44.  
  45.            Console.SetCursorPosition(0, 0);
  46.            Console.Write("Nombre del relé 1:  ");
  47.            Console.SetCursorPosition(0, 1);
  48.  
  49.            // Recorre el índice del array, del 0 hasta donde llegue.
  50.            for (int i = 0; i < roINDICE_ARRAY.Length; i++)
  51.            {
  52.                // Imprime los caracteres del array.
  53.                Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
  54.            }
  55.  
  56.            Console.SetCursorPosition(3, 3);
  57.            Console.Write(roTEXTO[0]); // ATRÁS.
  58.            Console.SetCursorPosition(12, 3);
  59.            Console.Write(roTEXTO[1]); // GUARDAR.
  60.        }
  61.  
  62.        #region Inico.
  63.        static void Inicio()
  64.        {
  65.            Console.SetWindowSize(20, 5); // Residemensiona pantalla. X = 20, Y = 5.
  66.            Console.BackgroundColor = ConsoleColor.Gray; // Fondo gris.
  67.            Console.ForegroundColor = ConsoleColor.Black; // Letras negras.
  68.  
  69.            // ¿El archivo Existe?
  70.            if (File.Exists("Archivo.txt"))
  71.            {
  72.                // Sí. Lee el archivo de texto.
  73.                string nombre = File.ReadAllText("Archivo.txt");
  74.                int a, b; // Almacena ídice array.
  75.                for (a = 0; a < nombre.Length; a++)
  76.                {
  77.                    for (b = 0; roALFANUMERICO[b] != nombre[a]; b++)
  78.                    {
  79.                        ;
  80.                    }
  81.                    roINDICE_ARRAY[a] = b; // b indica índice y lo añade al roINDICE_ARRAY.
  82.                }
  83.            }
  84.  
  85.            // No. El Archivo.txt no existe. El código continúa por aquí.
  86.  
  87.            MainMenu(); // Dibuja el menú.
  88.  
  89.            while (true)
  90.            {
  91.                Console.CursorVisible = true; // Cursor invisible.
  92.                index = 0;
  93.  
  94.                // Si se cumple estas condiciones, Enter, flecha izquierda, flecha derecha
  95.                if ((tecla == ConsoleKey.Enter) || (tecla == ConsoleKey.RightArrow) || (tecla == ConsoleKey.LeftArrow))
  96.                {
  97.                    MainMenu(); // Dibuja el menú.
  98.                }
  99.  
  100.                // Posiciona cursor.
  101.                Console.SetCursorPosition(coordenadaX, 1);
  102.  
  103.                // Almacena en la variable tecla, la tecla pulsada.
  104.                tecla = Console.ReadKey(true).Key;
  105.  
  106.                // Si coincide una tecla pulsada.
  107.                switch (tecla)
  108.                {
  109.                    case ConsoleKey.RightArrow: // Flecha derecha detectada.
  110.                        // ¿CoordenadaX menor que 15?
  111.                        if (coordenadaX < 15)
  112.                        {
  113.                            coordenadaX++; // Sí. Añada + 1 en la coordenadaX.
  114.                        }
  115.                        // No. Sale de aquí.
  116.                        break;
  117.  
  118.                    case ConsoleKey.LeftArrow: // Flecha izquierda detectada.
  119.                        // ¿coordenadaX es mayor que 0?
  120.                        if (coordenadaX > 0)
  121.                        {
  122.                            coordenadaX--; // Sí. Decremente o quita -1.
  123.                        }
  124.                        // No. Sale de aquí.
  125.                        break;
  126.  
  127.                    case ConsoleKey.UpArrow: // Flecha arriba.
  128.                        roINDICE_ARRAY[coordenadaX]++; // En el índice del array añade + en coordenadaX.
  129.                        // ¿El índice del array es mayor o igual que el arra Alfanumérico?
  130.                        if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
  131.                        {
  132.                            roINDICE_ARRAY[coordenadaX] = 0; // Sí. Deja en 0 la coordenada del índice del array.
  133.                        }
  134.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  135.                        break;
  136.  
  137.                    case ConsoleKey.DownArrow: // Flecha abajo detectado.
  138.                        roINDICE_ARRAY[coordenadaX]--; // Decrementa a -1 el índice del array.
  139.                        // ¿La coordenadaX del indice del array es menor que 0?
  140.                        if (roINDICE_ARRAY[coordenadaX] < 0)
  141.                        {
  142.                            // Sí. Imprimir el valor alfanumérico.
  143.                            roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
  144.                        }
  145.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  146.                        break;
  147.  
  148.                    case ConsoleKey.Enter: // Detecta la tecla Enter.
  149.                        Console.SetCursorPosition(1, 3); // Posición del cursor.
  150.                        Console.CursorVisible = false; // Se oculta el cursor.
  151.                        Console.Write(">"); // Imprime en pantalla >.
  152.  
  153.                        // ¿La tecla almacenada es distinto a la tecla Enter?
  154.                        while ((tecla = Console.ReadKey(true).Key) != ConsoleKey.Enter)
  155.                        {
  156.                            // Sí.
  157.                            switch (tecla)
  158.                            {
  159.                                case ConsoleKey.RightArrow:
  160.                                    index = 1;
  161.                                    Console.SetCursorPosition(1, 3);
  162.                                    Console.Write(" ");
  163.                                    Console.SetCursorPosition(10, 3);
  164.                                    Console.Write(">");
  165.                                    break;
  166.                                case ConsoleKey.LeftArrow:
  167.                                    Console.SetCursorPosition(10, 3);
  168.                                    Console.Write(" ");
  169.                                    Console.SetCursorPosition(1, 3);
  170.                                    Console.Write(">");
  171.                                    index = 0;
  172.                                    break;
  173.  
  174.                                case ConsoleKey.UpArrow:
  175.                                    Inicio();
  176.                                    break;
  177.  
  178.                                case ConsoleKey.DownArrow:
  179.                                    Inicio();
  180.                                    Console.SetCursorPosition(coordenadaX, 1);
  181.                                    break;
  182.                            }
  183.                        }
  184.  
  185.                        if (index == 0)
  186.                        {
  187.                            Atras();
  188.                        }
  189.                        if (index == 1)
  190.                        {
  191.                            Guardar();
  192.                        }
  193.                        break;
  194.                }
  195.            }
  196.        }
  197.        #endregion
  198.  
  199.        static void Atras()
  200.        {
  201.            Console.Clear();
  202.            Console.SetCursorPosition(0, 1);
  203.            Console.Write("HAS PULSADO ATRÁS   ");
  204.            Console.ReadKey(); // Pulse cualquier tecla para salir.
  205.        }
  206.  
  207.        static void Guardar()
  208.        {
  209.            guardarNombre = "";
  210.            Console.Clear();
  211.  
  212.            // Lee todo el contennido del array y lo guarda en guardarNombre.
  213.            for (int a = 0; a < roINDICE_ARRAY.Length; a++)
  214.            {
  215.                guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
  216.            }
  217.            Console.SetCursorPosition(0, 2);
  218.            Console.Write(guardarNombre); // Imprime el contenido.
  219.  
  220.            // Crear Archivo.txt y el contenido de guardarNombre.
  221.            File.WriteAllText("Archivo.txt", guardarNombre);
  222.  
  223.            Console.SetCursorPosition(0, 1);
  224.            Console.Write("HAS GUARDADO       ");
  225.  
  226.            // Pulsa otra vez tecla.
  227.            Console.ReadKey();
  228.        }
  229.    }
  230. }

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

;)



EI: Juntando mensajes, otra vez.

Me funciona hasta con Arduino.

Código
  1. #include <LiquidCrystal.h>
  2.  
  3. // Inicializa la librería con sus pines indicados.
  4. LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);
  5.  
  6. // Pin 10 para saber que es luz de fondo del LCD.
  7. //int LuzFondo = 10;
  8.  
  9.  
  10. // Variables.
  11. String guardarNombre = ""; // Guardar nombre escrito.
  12. int coordenadaX = 0; // Coordenada X del setCursorPisition.
  13. int index = 0; // Índice.
  14. // Caracteres de este array.
  15. char const PROGMEM ALFANUMERICO[] =
  16. {
  17.  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  18.  'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  19.  'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  20.  'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  21.  '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
  22. };
  23.  
  24. // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
  25. int const PROGMEM INDICE_ARRAY[] =
  26. {
  27.  80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
  28. };
  29.  
  30. // Palabras del array para imprimir en pantalla.
  31. String const TEXTO[] = { "ATRÁS", "GUARDAR" };
  32.  
  33. void setup()
  34. {
  35.  // La pantalla es de 16 caracteres y 2 filas.
  36.  lcd.begin(16, 2);
  37.  lcd.print(F("  Probando..."));
  38.  
  39.  // Baudios del puerto serie.
  40.  Serial.begin(115200);
  41.  
  42.  // Indicar luz de fondo como salida.
  43.  // pinMode(LuzFondo, OUTPUT);
  44.  
  45.  Serial.println(guardarNombre);
  46.  Serial.println(coordenadaX);
  47.  Serial.println(index);
  48.  
  49.  for (byte i = 0; i < 80; i++)
  50.  {
  51.    Serial.println(ALFANUMERICO[i]);
  52.  }
  53.  
  54.  for (byte j = 0; j < 16; j++)
  55.  {
  56.    Serial.println(INDICE_ARRAY[j]);
  57.  }
  58.  
  59.  for (byte k = 0; k < 2; k++)
  60.  {
  61.    Serial.println(TEXTO[k]);
  62.  }
  63. }
  64.  
  65. void loop()
  66. {
  67.  //return 0;
  68. }
« Última modificación: 30 Julio 2020, 01:16 por Eternal Idol » En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines