Hola:

En C++ nativo con Visual Studio Community 2019, tengo este código,  que no se muestra el cursor.

#include <iostream>
#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;
//using std::cout;
//using std::cin;
 
// Función posición del cursor.
void gotoxy(int x, int y)
{
	HANDLE hcon;
	hcon = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD dwPos;
	dwPos.X = x;
	dwPos.Y = y;
	SetConsoleCursorPosition(hcon, dwPos);
}
 
int main()
{
    	// 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");
 
	// Ocultar cursor.
	CONSOLE_CURSOR_INFO cci;
	GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
	cci.bVisible = 0; // 0 oculta. 1 muestra cursor.
	SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
 
	// Mostrar textos en pantalla.
	cout << "Terminarías. Conocerías. Título. Analógico. \n";
	cout << "Muchas gracias mi muy distinguido amigo.";
 
	// Limpiar pantalla.
	system("cls");
 
	// Mostrar textos en pantalla.
	cout << "Se escribe este texto después de haber " << endl;
	cout << "borrado el anterior." << endl;
 
	// Posición del cursor.
	gotoxy(5, 5);
 
	cout << "Posición." << endl;
 
	// Ocultar cursor.
	CONSOLE_CURSOR_INFO cci2;
	GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci2);
	cci2.bVisible = 1; // 0 oculta. 1 muestra cursor.
	SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci2);
 
	// Esperando pulsar Enter para salir.
	cin.get();
	return 0;
}

Si quito este código.

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

Se muestra el cursor parpadeando como siempre.

¿Esto es normal?

Para mi no lo es, una cosa es cambiar el color de la ventana y letras, es independiente al parpadeo del cursor si está activado o no.

Saludos.

Hola:

Antes que nada, no se si esto va aquí.
Hice un ejemplo con C# sobre el cambio de tamaño del array. Quiero ahcer lo mismo pero con Arduino IDE. Lo que se tiene que mostrar en ARduino IDE es en el "Monitor serie", en el cual se usa el comando:

Código C de Arduino IDE:

Serial.println("Se muestra este texto en el Monitor serie.");

El código que tengo abajo de C#, quiero de alguna forma transformarlo en Arduino IDE. En realidad este es un ejemplo tonto para que se entienda lo que hace de agrandar o reducir el tamaño del array en C#, pero quiero hacerlo en C de Arduino IDE.

Código C#:

sing System;
 
namespace Cambiar_tamaño_array_consola_02_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Tamaño del array";
 
            // Crea e inicializa una nueva matriz de cadenas.
            String[] miArray = {"Hola", "mi", "muy", "distinguido", "amigo",
            "¿Cómo", "estás", "por", "aquí?"};
 
            // Muestra los valores de la matriz.
            Console.WriteLine(
                "La matriz de cadenas contiene inicialmente los siguientes valores:");
            MostrarIndicesYValores(miArray);
 
            // Cambiar el tamaño de la matriz a un tamaño más grande (cinco elementos más grandes).
            Array.Resize(ref miArray, miArray.Length + 5);
 
            // Muestra los valores de la matriz.
            Console.WriteLine("Después de cambiar el tamaño a un tamaño más grande,");
            Console.WriteLine("la matriz de cadenas contiene los siguientes valores:");
            MostrarIndicesYValores(miArray);
 
            // Cambiar el tamaño de la matriz a un tamaño más pequeño (cuatro elementos).
            Array.Resize(ref miArray, 4);
 
            // Muestra los valores de la matriz.
            Console.WriteLine("Después de cambiar el tamaño a un tamaño más pequeño,");
            Console.WriteLine("la matriz de cadenas contiene los siguientes valores:");
            MostrarIndicesYValores(miArray);
 
            // Pulse cualquier tecla para salir.
            Console.ReadKey();
        }
 
        public static void MostrarIndicesYValores(String[] miArray)
        {
            for (int i = 0; i < miArray.Length; i++)
            {
                Console.WriteLine("   [{0}] : {1}", i, miArray[i]);
            }
            Console.WriteLine();
        }
    }
}
 

Mostrar captura de C#:



Saludos.

Hola:

Quiero crear un archivo excel llamado Archivo.xlsx en consola C#.

Los datos son estos.

h	V
1	4,429446918
2	6,264183905
3	7,672027112
4	8,858893836
5	9,904544412
6	10,84988479
7	11,71921499
8	12,52836781
9	13,28834075

Donde pone exactamente

4,429446918

Tiene este cálculo.

=RAIZ(2*9,81*A2)

También quiero saber, al menos si me crea gráfico incluido, lo hice a mano abajo, pare que vean de que hablo.


Ver Zoom.

Sin usar ninguna librería, esto ya es más complicado.

Saludos.

Hola:

¿El código morse en digital o analógico y por qué?

Como es del 1844 inventado por Samuel Morse, sobre puntos y rayas, en aquella época, ya unos 175 años, no había nada digital, por eso creo que es analógica, como solo es pulsar pulsadores un punto y otro más tiempo que es raya, solo es haber tensiones si pulsas y no haber nada si dejas de pulsar.

Ya no se que creer.

Saludos.

Hola:

Este código funciona a medias. Más bien, no logro situarlo. Está escrito en consola C#.

Lo que hace el programa:

Se usa solo las teclas flechas del teclado y la tecla Enter.

El programa empieza así;


Como puedes ver arriba, puedes escribir con las flechas arriba y abajo letras para poner un nombre. Por ejemplo, voy a poner Hola amigo. Lo puedes ver en la captura de abajo.



Pulsa Enter.
Se muestra el > al lado de ATRÁS. Tal como muestra abajo.


Lo que debe hace en esta parte indicado en la imagen de arriba es:
1. Si toco las flechas del teclado izquierda y derecha, me señala con > Atrás o en GUARDAR.
2. Si pulso las flecha arriba o abajo, puedes volver a editar la palabra "Hola amigo", puedes corregir o escribir otra cosa.
3. Si pulsas Enter donde estabas escribiendo "Hola amigo", vuelves en ATRÁS con el >.
4. Estando en > ATRÁS, si pulsas Enter, muestra un mensaje tal como muestra en la captura de abajo y el programa se acaba ahí.



El problema que no me funciona esta parte y la que voy a indicar ahora tampoco me funciona.
Si estoy en > ATRÁS, al pulsas las flechas derecha o izquierda, debo estar ya en > GUARDAR.

Precisamente no me sale.

A parte de esto, si pulsas Enter cuando estés en > GUARDAR. Se queda guardado el texto "Hola amigo" guardado en una variable que en este caso se llama static string guardarNombre = "";

Se tiene que mostrar la imagen de abajo.


Y se acaba el programa.

Me perdí. Alguna idea como se programa esto.

Código C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace LCD_nombre_archivo_consola_08
{
    class Program
    {
        static string guardarNombre = "";
        static int coordenadaX = 0;
        private static ConsoleKey tecla;
 
        // 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
        };
 
        private static readonly string[] roTEXTO = new string[] { "ATRÁS", "GUARDAR" };
 
        static int index = 0;
        static void Main(string[] args)
        {
            // Título de la pantalla.
            Console.Title = "Cambiar nombre";
 
            Inicio();
        }
 
        #region Inico.
        private static void Inicio()
        {
            // Tamaño de la ventana.
            Console.SetWindowSize(20, 5); // X 
 
            // Fondo verde, azul, gris.
            Console.BackgroundColor = ConsoleColor.Gray;
 
            // Letras negras, blanco, negro.
            Console.ForegroundColor = ConsoleColor.Black;
 
            // Limpiar pantalla.
            Console.Clear();
 
            Console.SetCursorPosition(0, 0);
            Console.Write("Nombre del relé 1:  ");
            Console.SetCursorPosition(0, 1);
            //Console.Write("AAAAAAAAAAAAAAAA");
 
            // Recorre todo el índice del array y el de los datos alfanumérico
            // y los rellena.
            for (int i = 0; i < roINDICE_ARRAY.Length; i++)
            {
                Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
            }
 
            Console.SetCursorPosition(2, 3);
            Console.Write(roTEXTO[0]); // ATRÁS.
            Console.SetCursorPosition(12, 3);
            Console.Write(roTEXTO[1]); // GUARDAR.
 
            while (true)
            {
                Console.SetCursorPosition(coordenadaX, 1);
 
                // Almacena cualquier tecla pulsada en la variable key.
                tecla = Console.ReadKey(true).Key;
                switch (tecla)
                {
                    case ConsoleKey.RightArrow:
                        if (coordenadaX < 15)
                        {
                            coordenadaX++;
                        }
                        break;
 
                    case ConsoleKey.LeftArrow:
                        if (coordenadaX > 0)
                        {
                            coordenadaX--;
                        }
                        break;
 
                    case ConsoleKey.UpArrow:
                        roINDICE_ARRAY[coordenadaX]++;
                        if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
                        {
                            roINDICE_ARRAY[coordenadaX] = 0;
                        }
                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                        break;
 
                    case ConsoleKey.DownArrow:
                        roINDICE_ARRAY[coordenadaX]--;
                        if (roINDICE_ARRAY[coordenadaX] < 0)
                        {
                            roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
                        }
                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                        break;
 
                    case ConsoleKey.Enter:
                        Console.SetCursorPosition(1, 3);
                        Console.CursorVisible = false;
                        Console.Write(">");
 
                        while (true)
                        {
                            tecla = Console.ReadKey(true).Key;
 
                            switch (tecla)
                            {
                                case ConsoleKey.RightArrow:
                                case ConsoleKey.LeftArrow:
                                    index = 1 - index;
                                    break;
 
                                case ConsoleKey.UpArrow:
                                case ConsoleKey.DownArrow:
                                    Console.SetCursorPosition(coordenadaX, 1);
                                    break;
 
                                case ConsoleKey.Enter:
 
                                    break;
                            }
 
                            for (int a = 0; a < 2; a++)
                            {
                                Console.SetCursorPosition(1 + (10 * a), 3);
                                if (a == index)
                                {
                                    Console.Write(">");
                                }
                                else
                                {
                                    Console.Write(" ");
                                }
                            }
 
                            if (index == 0)  // se pulsó Atrás
                            {
                                Atras();
                                //break;  // vuelve a la edición de letras
                            }
 
                            if (index == 1)  // se pulsó Guardar
                            {
                                Guardar();
                            }
                        }
                }
            }
        }
        #endregion
 
        private static void Atras()
        {
            Console.Clear();
            Console.SetCursorPosition(0, 1);
            Console.Write("HAS PULSADO ATRÁS   ");
            Console.ReadKey(); // Pulse cualquier tecla para salir.
        }
 
        private static void Guardar()
        {
            Console.Clear();
            Console.SetCursorPosition(0, 1);
            Console.Write("HAS GUARDADO       ");
            for (int a = 0; a < roINDICE_ARRAY.Length; a++)
            {
                guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
            }
            Console.SetCursorPosition(0, 2);
            Console.Write(guardarNombre);
        }
    }
}
 

Gracias.

Buenas:

Tengo este código en C++ nativo, en el cual aún no logro que funcione tal como lo quiero. Lo que hace este código es, que si pulsas la letra A o a, se abre la bandeja del lector del disco, si pulsas C o c se cierra.

Código C++ nativo:

#include <iostream>
#include <windows.h> // Para mostrar texto en el título de la ventana.
 
using namespace std;
//using std::cout;
//using std::cin;
 
// Función posición del cursor.
void gotoxy(int x, int y)
{
	HANDLE hcon;
	hcon = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD dwPos;
	dwPos.X = x;
	dwPos.Y = y;
	SetConsoleCursorPosition(hcon, dwPos);
}
 
int main(void)
{
	// Mostrar caracteres correctamente en pantalla y título de la ventana.
	SetConsoleOutputCP(65001);
	wchar_t titulo[128];
	MultiByteToWideChar(CP_UTF8, 0, "Consola C++ nativo 2019.", -1, titulo, 128);
	SetConsoleTitle(titulo);
 
	// Variable.
	char entrada[] = "\0"; // Guarda A, a, C, y c tipo string que introduces desde la consola.
 
	// Tamaño de la pantalla. Se cambia en los dos últimos dígitos.
	SMALL_RECT r = { 0, 0, 29, 8 }; // X = 29, Y = 8.
	SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &r);
 
	// Ocultar cursor.
	CONSOLE_CURSOR_INFO cci;
	GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
	cci.bVisible = 0; // 0 oculta. 1 muestra cursor.
	SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
 
	// Muestra textos en pantalla.
	cout << "Control bandeja del lector: " << endl << endl;
	cout << "A - Abrir bandeja." << endl;
	cout << "C - Cerrar bandeja." << endl;
	cout << "===========================" << endl;
 
	while (true)
	{
 
 
		// Aquí introduces letras A, a, C y c.
		cin >> entrada; 
		cout << "\n" << endl;
 
		// Abrir bandeja.
		if ((entrada[0] == 'a') || (entrada[0] == 'A'))
		{
			// Posición del cursor.
			gotoxy(0, 6);
			cout << "Abriendo..." << endl << endl; // Muestra texto en pantalla.
			mciSendString(L"set cdaudio door open", nullptr, 0, nullptr);
			gotoxy(0, 6);
			cout << "Abierto.   " << endl << endl; // Muestra texto en pantalla.
		}
 
		// Cerrar bandeja.
		else if ((entrada[0] == 'c') || (entrada[0] == 'C'))
		{
			gotoxy(0, 6);
			cout << "Cerrando..." << endl << endl; // Muestra texto en pantalla.
			mciSendString(L"set cdaudio door closed", nullptr, 0, nullptr);
			gotoxy(0, 6);
			cout << "Cerrado.   " << endl << endl; // Muestra texto en pantalla.
		}
 
		// Si haz pulsado otro caracter distinto de A, C, a y c aparece
		else
		{
			gotoxy(0, 6);
			// este mensaje.
			cout << "Solo pulsa A o C." << endl << endl;
		}
 
	}
	return EXIT_SUCCESS;
}

En el código de C# si funciona tal como lo quiero, pongo un ejemplo abajo.

Código C#:

using System;
using System.Runtime.InteropServices;
using System.Text;
namespace Bandeja_consola_cs
{
    class Program
    {
        [DllImport("winmm.dll")]
        public static extern Int32 mciSendString(string lpstrCommand, StringBuilder lpstrReturnString,
        int uReturnLength, IntPtr hwndCallback);
        public static StringBuilder rt = new StringBuilder(127);
        public static void DoEventsAbriendo()
        {
            Console.SetCursorPosition(0, 6);
            Console.Write("Abriendo...");
        }
        public static void DoEventsCerrando()
        {
            Console.SetCursorPosition(0, 6);
            Console.Write("Cerrando...");
        }
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Consola C# 2017";
            // Tamaño ventana consola.
            Console.WindowWidth = 29; // X. Ancho.
            Console.WindowHeight = 8; // Y. Alto.
            // Cursor invisible.
            Console.CursorVisible = false;
            // Posición del mansaje en la ventana.
            Console.SetCursorPosition(0, 0);
            Console.Write(@"Control bandeja del lector:
A - Abrir bandeja.
C - Cerrar bandeja.
===========================");
            ConsoleKey key;
            //Console.CursorVisible = false;
            do
            {
                key = Console.ReadKey(true).Key;
                string mensaje = string.Empty;
                //Asignamos la tecla presionada por el usuario
                switch (key)
                {
                    case ConsoleKey.A:
                        // mensaje = "Abriendo...";
                        Console.SetCursorPosition(0, 6);
                        DoEventsAbriendo();
                        mciSendString("set CDAudio door open", rt, 127, IntPtr.Zero);
                        mensaje = "Abierto.   ";
                        break;
                    case ConsoleKey.C:
                        // mensaje = "Cerrando...";
                        Console.SetCursorPosition(0, 6);
                        DoEventsCerrando();
                        mciSendString("set CDAudio door closed", rt, 127, IntPtr.Zero);
                        mensaje = "Cerrado.   ";
                        break;
                }
                Console.SetCursorPosition(0, 6);
                Console.Write(" ");
                Console.SetCursorPosition(0, 6);
                Console.Write(mensaje);
            }
            while (key != ConsoleKey.Escape);
        }
    }
}

Lo que hace el código C# exactamente todos estos comportamientos.

1. Te pregunta si pulsas teclas, por ejemplo la A para abrir la bandeja y C para cerrar, independientemente si es mayúscula o no. Funciona todo.

2. Desde que pulse cualquier letra del teclado que non corresponda la A, a, C y la c, el programa no hace nada, como debe ser.

3. Si quiero abrir la bandeja del lector y pulso la tecla A, desde que pulse la tecla, se abre la bandeja.

4. Desde que pulse la tecla A, dice el mensaje "Abriendo...", cuando esté abierto la bandeja del todo, dice "Abierto.".

Lo que hace el código C++ nativo y no quiero.

1. Pulso la tecla A o la a, y aparece escrito en la consola.

2. Luego tengo que pulsar la tecla Enter para que la letra A o la a, funcione el comando. Entonces ya puede abrir la bandeja y mostrar los mensajes Abriendo... y Aabierto.

La pregunta es. ¿Se puede corregir este comportamiento de C++ nativo que sea igual al ejemplo de C#?

Saludos.

Buenas:

Usando Windows Form C# hice este código.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace prueba_cs
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            timer1.Start();
        }
 
 
 
        void cambioColor()
        {
            this.BackColor = Color.Black; // Formulario negro.
            //this.ForeColor = Color.White; // Cambia textos en blanco.
            label1.ForeColor = Color.White;
        }
 
        void cambioColor2()
        {
            this.BackColor = Color.White; // Formulario blanco.
            //this.ForeColor = Color.Black; // Cambia textos en negro.
            label1.ForeColor = Color.Black;
        }
 
        private void timer1_Tick(object sender, EventArgs e)
        {
            cambioColor();
            timer1.Stop();
            timer2.Start();
        }
 
        private void timer2_Tick(object sender, EventArgs e)
        {
            cambioColor2();
            timer2.Stop();
            timer1.Start();
        }
    }
}

Se sale del formulario pulsando Alt + F4. Quiero que se desactive el puntero del ratón en el momento que cree este formulario.

Gracias.

Hola:

Haciendo otras pruebas.

Creo el archivo dll.

#include "pch.h"
 
extern "C" 
{
    __declspec(dllexport) LPTSTR __stdcall Mensaje();
    __declspec(dllexport) float __stdcall Volumen(float, float, float, float);
    __declspec(dllexport) float __stdcall Litros(float, float);
    __declspec(dllexport) float __stdcall ResultadoPorcentaje(float, float, float);
    __declspec(dllexport) float __stdcall VolumenLitros(float, float, float, float, float);
    __declspec(dllexport) float __stdcall CantidadTubosLitros(float, float, float);
    __declspec(dllexport) float __stdcall TotalLitros(float, float, float);
};
 
// Mensaje.
LPTSTR __stdcall Mensaje() { return LPTSTR(L"Hola. Saludos desde la dll. Versión: 1.0.0"); }
 
// Cálculo volumen.
float __stdcall Volumen(float volumen, float PI, float radio, float altura)
{
    return volumen = PI * (radio * radio) * altura;
}
 
// Cálculo litros.
float __stdcall Litros(float litros, float volumen)
{
    return litros = volumen * 1000;
}
 
// Cálculo porcentaje en % del litro de agua.
float __stdcall ResultadoPorcentaje(float resultadoPorcentaje, float nivelAgua, float altura)
{
    return resultadoPorcentaje = nivelAgua * (100 / altura);
}
 
// Cálculo litros de agua.
float __stdcall VolumenLitros(float volumenLitros, float PI, float radio, float nivelAgua, float resultadoLitros)
{
    return volumenLitros = PI * (radio * radio) * nivelAgua;
    return resultadoLitros = volumenLitros * 1000;
}
 
// Cálculo litros por cantidad de tubos
float __stdcall CantidadTubosLitros(float cantidadTubosLitros, float cantidadTubos, float resultadoLitros)
{
    return cantidadTubosLitros = cantidadTubos * resultadoLitros;
}
 
// Cálculo cantidad de litros con total de tubos.
float __stdcall TotalLitros(float totalLitros, float litros, float cantidadTubos)
{
    return totalLitros = litros * cantidadTubos;
}

Luego el deb.

LIBRARY DLL_al_poder
EXPORTS
Mensaje
Volumen
Litros
ResultadoPorcentaje
VolumenLitros
CantidadTubosLitros
TotalLitros

Y la interfaz de C++ nativo para que lea la dll.

#include <iostream>
#include <windows.h> // Para mostrar texto en el título de la ventana.
 
using namespace std;
//using std::cout;
//using std::cin;
 
// Función posición del cursor.
void gotoxy(int x, int y)
{
	HANDLE hcon;
	hcon = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD dwPos;
	dwPos.X = x;
	dwPos.Y = y;
	SetConsoleCursorPosition(hcon, dwPos);
}
 
// Definir estas funciones.
typedef LPTSTR(__stdcall* Mensaje)();
typedef float(__stdcall* Volumen)(float, float, float, float);
typedef float(__stdcall* Litros)(float, float);
typedef float(__stdcall* ResultadoPorcentaje)(float, float, float);
typedef float(__stdcall* VolumenLitros)(float, float, float, float, float);
typedef float(__stdcall* CantidadTubosLitros)(float, float, float);
typedef float(__stdcall* TotalLitros)(float, float, float);
 
int main(void)
{
	// Variables.
	const double Pi = 3.14;
	float radio;
	float altura;
	//double volumen;
	//double litros;
	float nivelAgua;
	//float resultadoPorcentaje;
	//double resultadoLitros;
	//double volumenLitros;
	float mitadBarra;
	float cantidadTubos;
	//double cantidadTubosLitros;
	//double totalLitros;
 
	// Importar dll.
	HINSTANCE hDLL = 0;
	Mensaje mensaje;
	Volumen volumen;
	Litros litros;
	ResultadoPorcentaje resultadoPorcentaje;
	VolumenLitros volumenLitros;
	CantidadTubosLitros cantidadTubosLitros;
	TotalLitros totalLitros;
 
	hDLL = LoadLibrary(L"C:\\Users\\Meta\\Documents\\Visual Studio 2019\\Projects\\DLL_y_interfaz_nativo_01_cpp\\Debug\\DLL_y_interfaz_nativo_01_cpp.dll");
	mensaje = (Mensaje)GetProcAddress(hDLL, "Mensaje");
	volumen = (Volumen)GetProcAddress(hDLL, "Volumen");
	litros = (Litros)GetProcAddress(hDLL, "Litros");
	resultadoPorcentaje = (ResultadoPorcentaje)GetProcAddress(hDLL, "ResultadoPorcentaje");
	volumenLitros = (VolumenLitros)GetProcAddress(hDLL, "VolumenLitros");
	cantidadTubosLitros = (CantidadTubosLitros)GetProcAddress(hDLL, "CantidadTubosLitros");
	totalLitros = (TotalLitros)GetProcAddress(hDLL, "totalLitros");
 
	// Mostrar caracteres correctamente en pantalla y título de la ventana.
	SetConsoleOutputCP(65001);
	wchar_t titulo[128];
	MultiByteToWideChar(CP_UTF8, 0, "Interfaz leer dll C++ nativo 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, 35 }; // X = 49, Y = 9.
	SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &r);
 
	// Ocultar cursor.
	CONSOLE_CURSOR_INFO cci;
	GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
	cci.bVisible = 1; // 0 oculta cursor. 1 muestra cursor.
	SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
 
	// Posición del cursor.
	gotoxy(3, 2);
 
	// Mostrar textos en pantalla.
	wcout << mensaje() << endl;
	gotoxy(0, 4);
	cout << "Introduce el radio en m.: ";
	cin >> radio;
	cout << "Introduce la altura en m. ";
	cin >> altura;
	cout << "Introduce altura del agua. Máximo es de " << altura << ":";
	cin >> nivelAgua;
	cout << "Introduces cantidad de tubos: ";
	cin >> cantidadTubos;
 
	// ########## Dibujo de la barra.
	cout << "\n";
	cout << ("0 %                     50 %                   100 %") << endl;
	cout << ("&#9484;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9516;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9472;&#9488;") << endl;
 
	// Mitad de la barra para que no sea muy grande en la pantalla.
	mitadBarra = resultadoPorcentaje / 2;
 
	if (mitadBarra > 50)
	{
		mitadBarra = 50;
	}
 
	// Rellenar la barra.
	for (float i = 1; i <= mitadBarra; i++)
	{
		cout << ("&#9608;");
	}
 
	// Si llega a 100 se pone el # en rojo.
 
	if (resultadoPorcentaje > 100)
	{
		cout << ("#");
	}
	//########## Fin dibujo de la barra.
 
	// Pisición del texto a mostrar.
	gotoxy(0, 11);
 
	//cout << "\nPorcentaje: " << resultadoPorcentaje << " %.";
 
 
	FreeLibrary(hDLL);
 
	// Esperando pulsar Enter para salir.
	cin.get();
	return 0;

Me salen estos errores.


No logro solucionarlo.

Buenas:

En este ejemplo de código gracias al equipo de este foro. Los datos de selección de un radioButton en consola C#, se guarda en la RAM o en una variable.

Quiero saber el archivo recomendado para guardar dicho dato y luego recuperarlo nada más arrancar el programa. Por supuesto, si selecciono con Enter la "> (*) Opción E", se guarda automáticamente este dato en un archivo.

¿Qué tipo de archivo aconsejable para guardar datos y recuperarlo?

Me comenta que en binario, porque es lo que trabaja las computadoras, más rápido y eficientes para ella. Para nosotros pensé en un archivo de texto txt. Para otros prefieren el XML, otros el editor de registro en el cual ahora dicen mejor no manejarlo para no saturarlo.

Alguien sabrá.

El código es este de abajo.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace radioButton_consola_03_cs
{
    class Program
    {
        #region Variables.
        private static readonly string[] TEXTO = new string[]
        {
            "( ) Opción A        ",
            "( ) Opción B        ",
            "( ) Opción C        ",
            "( ) Opción D        ",
            "( ) Opción E        ",
            "( ) Opción F        ",
            "( ) Opción G        ",
            "    SALIR"
        };
 
        private static int itemSeñalado;
 
        private static int itemSeleccionado;
        #endregion
 
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "RadioButton";
 
            // Tamaño de la ventana.
            Console.SetWindowSize(20, 5);
 
            // Fondo azul.
            Console.BackgroundColor = ConsoleColor.Blue;
 
            // Letras blanco.
            Console.ForegroundColor = ConsoleColor.White;
 
            // Oculto el cursor.
            Console.CursorVisible = false;
 
            // Almacena la tecla pulsada en la variable.
            ConsoleKey teclaInicial;
 
            do
            {
                // Limpiar pantalla.
                Console.Clear();
 
                // Posición del cursor del título del MENÚ PRINCIPAL.
                Console.SetCursorPosition(0, 0);
 
                // Título.
                Console.Write("   MENÚ PRINCIPAL   ");
 
                // Pocisión de la hora.
                Console.SetCursorPosition(4, 2);
 
                // Formato numérico dd/MM/yyyy.
                Console.Write(DateTime.Now.ToString("ddd dd MMM"));
 
                // Almacena en la variable una tecla pulsada.
                teclaInicial = Console.ReadKey(true).Key;
 
                // ¿Haz pulsado la tecla Enter?
                if (teclaInicial == ConsoleKey.Enter)
                {
                    // Sí. Se ejecuta esta función.
                    MenuPrincipal();
                }
            } while (teclaInicial != ConsoleKey.Escape);
        }
 
        #region Menú Principal.
        private static void MenuPrincipal()
        {
            bool salir = false;
 
            // En itemSelecionado:
            // -1 = Sin seleccionar con * ninguna opción.
            // 0 = Seleccionar con * la Opción A.
            // 1 = Seleccionar con * la Opción B.
            // 2 = Seleccionar con * la opción C.
            // 3 = Seleccionar con * la opción D.
            // 4 = Seleccionar con * la opción E.
            // 5 = Seleccionar con * la opción F.
            // 6 = Seleccionar con * la opción G.
 
            // Capturar tecla para luego validar.
            ConsoleKey tecla;
 
            // Cada vez que se vuelva al menú, está señalizado con el *.
            itemSeñalado = 0;
            int pagina;
            do
            {
                //******************************************************************
                // Dibujo el menú principal.
 
                // Limpiar pantalla.
                Console.Clear();
 
                pagina = 0;
                if (itemSeñalado >= 4)
                {
                    pagina = 4;
                }
 
                // Recorre la lista de las opciones.
                for (int k = 0; k < 4; k++)
                {
                    Console.SetCursorPosition(0, k);
                    Console.Write(itemSeñalado == k + pagina ? "> " : "  ");
                    Console.Write(TEXTO[k + pagina]);
                    Console.SetCursorPosition(3, k);
                    Console.Write(itemSeleccionado == k + pagina ? "*" : " ");
                }
 
                // Fin de pintar el menú principal.
                //******************************************************************
 
                // Leer tecla ingresada por el usuario.
                tecla = Console.ReadKey(true).Key;
 
                switch (tecla)
                {
                    // Al pulsar Enter, marcas un radioButton con *.
                    case ConsoleKey.Enter:
                        if (itemSeñalado < 7)
                        {
                            itemSeleccionado = itemSeñalado;
                        }
                        salir = (itemSeñalado == TEXTO.Length - 1);
                        break;
 
                    // Pulsar flecha abajo del teclado.
                    case ConsoleKey.DownArrow:
                        if (++itemSeñalado >= TEXTO.Length)
                        {
                            itemSeñalado = 0;
                            Console.Clear();
                        }
                        else if (itemSeñalado == 4)
                        {
                            Console.Clear();
                        }
                        break;
 
                    // Pulsar flecha arriba del teclado.
                    case ConsoleKey.UpArrow:
                        if (--itemSeñalado < 0)
                        {
                            itemSeñalado = TEXTO.Length - 1;
                            Console.Clear();
                        }
                        else if (itemSeñalado == 3)
                        {
                            Console.Clear();
                        }
                        break;
                }
                // Uso la tecla escape como salida.
            } while (!salir);
        }
        #endregion
    }
}

Por supuesto. Se guarda los datos desde que se pulse Enter. Tengo entendido que el archivo a guardar si no hay ninguno o no lo detecta por ejemplo a este nombre, por ejemplo Archivo.txt. Lo crea. Si está creado, solo lo lee y guarda datos.

Desde que pulse Enter en > Salir se guarda los datos. Si pulsas la X con el ratón (mouse) de la ventana del programa, también se asegura que se cierra el archivo y tenga todo guardado por si acaso, no quiero tener error de archivos.

Saludos.

Buenas:

Teniendo un código de Python 2.x, quiero adaptarlo a la consola C# si es posible. Si no, pues con Windows Form.
Ya no recuerdo casi nada de Python y quiero tenerlo en C#.

El código del Pyhon es este.

import os, sys, tkFileDialog,Tkinter
 
root = Tkinter.Tk()
root.withdraw()
 
formats = [ ('Roms Super Nintendo SMC','.smc'),('Roms Super Nintendo SFC','.sfc'),('Fichier Bin','.bin'),('Roms Super Nintendo','.smc .sfc .bin') ]
 
input = tkFileDialog.askopenfile(parent=root,mode='rb',filetypes=formats,
                                 title='Seleccione el archivo para intercambiar bin HI a LO como A16->A15, A17->A16...A21->A20 y A15->21')
if not input:
    print "Error: no se puede abrir el archivo."
    sys.exit()
 
output = tkFileDialog.asksaveasfile(parent=root,mode='wb',filetypes=formats,title='Crear nombre de archivo de salida.')
if not output:
    print "Error: no se puede crear el archivo de salida."
    sys.exit()
 
 
    # reading input file to a byte array
    data = bytearray(input.read())
 
    # calculating rom size in 2 exponants
    expsize = 0
    bytesize = len(data)
    while bytesize > 1:
            expsize += 1
            bytesize = bytesize // 2
 
    # init a proper size empty bytearray
    buffer = bytearray()
    for i in range(2**expsize): buffer.append(0)
 
    # let's do the swap	
    count = 0	
    for i in range(len(data)):
            addr = (i & 0x7fff) + ((i & 0x008000) << (expsize - 16)) + ((i & 0x010000) >> 1) + ((i & 0x020000) >> 1) + ((i & 0x040000) >> 1) 
            + ((i & 0x080000) >> 1) +	((i & 0x100000) >> 1) + ((i & 0x200000) >> 1)
            if addr != i: count += 1
            buffer[addr] = data[i]
    print "Intercambiadas %s (%s) direcciones" % (count, hex(count))
 
    # writing output file
    output.write(buffer)
 
    # close file handles
    input.close()
    output.close()

Es cierto que con Visual Studio Community 2019 me ejecuta bien el Python, pero dependo de compilador y con C# no.

Esto parece una tarea muy complicada.

Muchas gracias.