domingo, 13 de diciembre de 2020

Solución de Access denied en MySQL

Si aparece el error Access denied for user 'root'@'localhost' y se está empleando MySQL versión 8, la solución más sencilla es ejecutar en la línea de comandos de MySQL cualquiera de las siguientes sentencias dependiendo si se desea establecer o no una contraseña


Solución en LINUX

En el caso de LINUX el primer paso es abrir el terminal CTRL + ALT + T. Luego ingresar a la consola de MySQL con el comando:

sudo mysql -u root

Solución en WINDOWS

El primer paso en WINDOWS es abrir el CMD con WINDOWS + R o desde el menú inicio escribiendo CMD. Luego ingresar a la consola de MySQL con el comando:

mysql -uroot -p

Luego ingresar cualquiera de las siguientes dos opciones

Sin contraseña


  ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY ''
  

Con contraseña


  ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'clave';
  

viernes, 27 de noviembre de 2020

Creando una tabla en SQLite

Crear la base de datos

Se requiere de un programa que administre bases de datos de SQLite para crear las bases de datos y opcionalmente comprobar si los cambios realizados por aplicaciones externas funcionan. Se puede emplear alguno de estos u otros:

Las bases de datos de SQLite son archivos en lugar de un conjuntos de carpetas y archivos contenidos en un servidor, por lo cual no requieren un puerto.

Una vez instalado el programa, se selecciona la opción de agregar una base de datos

Se agrega una base de datos, se puede seleccionar una existente o crear una nueva

Se procede a crear una base de datos con la extensión "db" y luego realizar un test de conexión

Finalmente, aceptar


Crear la tabla

Mediante el programa se puede crear la tabla y las columnas seleccionando la base de datos:


Luego se debe seguir una serie de pasos para agregar columnas y configurarlas.

  1. Indicar el nombre de la tabla
  2. Agregar columnas
  3. Indicar el nombre de la columna y su tipo, adicionalmente el tamaño. Por ejemplo, columnas que contienen texto o números con decimales.
  4. Indicar los restricciones (constraints) como clave primaria, foránea, campo único, etc.
  5. En algunos casos es necesario agregar una configuración adicional a las restricciones.
  6. Por ejemplo, en los campos PRIMARY KEY de tipo entero, el autoincremento. Además, se puede colocar un nombre a la restricción. Por ejemplo, necesario para claves foráneas.
  7. Finalmente aplicar cambios y repetir el proceso para cada columna que se desee agregar.

Se confirman los cambios, luego aparece el código SQL generado que se puede guardar para tener un Script.



Código SQL

Si se desea, se puede colocar el código directamente, para ello se debe seleccionar el editor SQL como se muestra.

En el editor SQL se debe ingresar lo siguiente y ejecutar (F9 en Windows).

CREATE TABLE inquilinos (
    idinquilinos  INTEGER         PRIMARY KEY AUTOINCREMENT,
    dni           VARCHAR (8)     UNIQUE
                                  NOT NULL,
    nombres       VARCHAR (150)   NOT NULL,
    paterno       VARCHAR (150)   NOT NULL,
    materno       VARCHAR (150)   NOT NULL,
    telefono      VARCHAR (40),
    correo        VARCHAR (200),
    deuda         DECIMAL (10, 2) NOT NULL,
    fecha_ingreso DATE            NOT NULL
);

Finalmente, se podrá apreciar la estructura de la tabla dentro de la base de datos. Cabe recordar que la base de datos "blog.db" es un archivo que estará ubicado en la dirección seleccionada inicialmente y puede ser trasladado donde deseemos.


domingo, 11 de octubre de 2020

Clases y objetos en C++

Objetos

Según la POO son bloques de código que permiten representar cosas (reales o imaginarias) como una persona o una venta. Los objetos se dividen en tres partes:

  • El estado: conjunto de campos o variables (atributos o miembros)
  • El comportamiento: las funciones (métodos o funciones miembro)
  • La identidad: permite identificar un objeto de otro. De forma que cada objeto es identificable respecto a los demás.

Clases

Son estructuras que define las características que tendrá un objeto. Esto es lo que se llama encapsulamiento y es uno de los pilares de la POO.

Atributos

Son un conjunto de variables que definen el estado de una clase pueden ser tipos básicos:
  • int
  • float
  • char
  • bool
  • Tipo colecciones (array), vectores u otros objetos.
Estas no deben ser accesibles desde el exterior, por lo que debe ser de tipo privado.

Metodos

Estos permiten acceder y modificar el estado de una clase.Tenemos dos clases especiales: el constructor y el destructor (el primero permite inicializar o instanciar una clase y el otro liberar recursos)

Además, existen los tradicionales métodos de acceso llamados GET que permiten extraer o mostrar el contenido de los atributos, generalmente sin parámetros salvo en colecciones u otros casos. Debe ser de tipo público. También, están los de modificación llamados SET que permiten modificar desde el exterior el contenido de los atributos asegurando la integridad de la clase, generalmente tienen un parámetro que coincide con el tipo de dato al que desean modificar y son públicos.


#include<iostream>
using namespace std;

class point{
	private:
		double x;
		double y;
	public:		
		//Constructor
		point(double x=0.0,double y=0.0):
			x(x),y(y)// Inicialización
			{}// Sin asignación
            
		//Métodos SET y GET	
		double getX() const {return this->x;}
		setX(double x){this->x=x;}
		double getY() const {return this->y;}
		setY(double y){this->y=y;}
		
		/*Destructor*/
		~point(){
			cout<<endl<<"Elemento destruido"<<endl<<endl;
		}		
};

Tangram con MiniWin

En el siguiente ejemplo se van a recrear las piezas de un tangram empleando triángulos rectángulos para formarlas.

Esto implica crear una o varias funciones para dibujar los triángulos rectángulos. En este caso se optó por usar cuatro funciones llamadas:

  • tipoA
  • tipoB
  • tipoC
  • tipoD

Estas podrían ser "inline", pero se optó por funciones convencionales, las funciones serían:

/*Trabajando con 4 tipos de triángulos rectángulos*/
void tipoA(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+ta-i,y1+i,x1+ta,y1+i);	
	}
}
void tipoB(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+i,y1+i);	
	}
}
void tipoC(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+i,y1+i,x1+ta,y1+i);	
	}
}
void tipoD(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+ta-i,y1+i);	
	}
}

Donde cada función corresponde a:

Tipo A Tipo B
    *
   **
  ***
 ****
*****
*
**
***
****
*****
Tipo C Tipo D
*****
 ****
  ***
   **
    *
*****
****
***
**
*

El código completo sería:

#include "miniwin.h"
using namespace miniwin;

const int DIM = 200; // Valor medio del ancho

/*Funciones */
void tipoA(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+ta-i,y1+i,x1+ta,y1+i);	
	}
}
void tipoB(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+i,y1+i);	
	}
}
void tipoC(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+i,y1+i,x1+ta,y1+i);	
	}
}
void tipoD(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+ta-i,y1+i);	
	}
}

int main(){
	vredimensiona(2*DIM, 2*DIM);	
	color_rgb(0, 0, 0);
	rectangulo_lleno(0, 0, 2*DIM, 2*DIM);
	
	/*Pieza 1*/
	color(AZUL);
	tipoB(0,0,DIM);
	tipoD(0,DIM,DIM);
	
	/*Pieza 2*/
	color_rgb(255, 150, 0);	
	tipoC(0,0,DIM);
	tipoD(DIM,0,DIM);	
	
	/*Pieza 3*/
	color(VERDE);	
	tipoA(DIM*1.5,0,DIM/2);
	rectangulo_lleno(DIM*1.5,DIM/2,2*DIM,DIM);
	tipoD(DIM*1.5,DIM,DIM/2);
	
	/*Pieza 4*/
	color(ROJO);	
	tipoA(DIM,DIM,DIM);
	
	/*Pieza 5*/
	color(MAGENTA);	
	tipoA(0,DIM*1.5,DIM/2);
	tipoB(DIM/2,DIM*1.5,DIM/2);
	
	/*Pieza 6*/
	color(AMARILLO);	
	tipoA(DIM/2,DIM,DIM/2);
	tipoB(DIM,DIM,DIM/2);
	tipoC(DIM/2,DIM*1.5,DIM/2);
	tipoD(DIM,DIM*1.5,DIM/2);
	
	/*Pieza 7*/
	color_rgb(100,0,155);	
	tipoA(DIM,DIM/2,DIM/2);
	tipoC(DIM,DIM,DIM/2);
	
	refresca();
	return 0;

}

El resultado visual sería:




domingo, 13 de septiembre de 2020

MiniWin con C++


MiniWin es una pequeña biblioteca gráfica para el lenguaje C++ que permite crear una ventana, pintar en ella, detectar la presión de las teclas. Además del movimiento y botones del mouse

Estructura básica de un programa con MiniWin

Un programa que implemente esta biblioteca debe tener la siguiente estructura:

#include "miniwin.h"
using namespace miniwin;

int main(){
	// Código que implementa las funciones de MinWin
	return 0;
}

Ejemplos:
#include "miniwin.h"
using namespace miniwin;

int main(){
	/* Creando un mensaje en un ventana */
	vredimensiona(400, 300);
   	rectangulo(100, 100, 300, 200);
   	texto(145, 142, "Bienvenidos a C++");
   	refresca();
	return 0;
}

#include "miniwin.h"
using namespace miniwin;

int main(){
	/*Crea la ventana*/
	vredimensiona(200, 200);
	
	// Dibujando una línea
	linea(0, 0, 200, 200);
	
	// Dibujando un rectángulo amarillo
	color(AMARILLO);//Asigna color
	rectangulo(10, 10, 50, 50);
	
	// Dibujando una circunferencia roja
	color(ROJO);//Asigna color
	circulo(150, 50, 20);
	
	// Dibujando un círculo relleno azul
	color(AZUL);//Asigna color
	circulo_lleno(100, 100, 20);
	
	// Dibujando un rectángulo relleno verde
	color(VERDE);//Asigna color
	rectangulo_lleno(150, 150, 200, 200);
	
	refresca();//Dibuja en pantalla
	return 0;
}


Fuentes y enlaces externos:

jueves, 10 de septiembre de 2020

Estructuras en C++

Estructuras condicionales

Estas permiten ejecutar bloques de sentencias de código para una determinada condición, si esta no se cumple se puede optar por no realizar nada o llevar a cabo otro bloque de sentencias, de manera que no pueden ejecutarse ambos bloques, solo uno de ellos.



Condicional IF ELSE Condicional SWITCH CASE
if (condicion1) {
   //Sentencias si 
   //Condicion1 es verdad
}else if (condicion2) {
   //Sentencias si 
   //Condicion2 es verdad
}else {
   //Sentencias si condicion1 y
   //condicion2 no son verdad
}
switch (expresión) {
case x :
   //Sentencias si expresión es "x"
   break;
case y :
   //Sentencias si expresión es "y"
   break;
default:
   //Sentencias para otros casos
}

Aplicación

El siguiente programa pide dos valores al usuario y los compara mostrando el mayor o ambos si son iguales.

#include <iostream>
using namespace std;

int main()
{
	int a;
	int b;
	cout << "Ingrese dos números\n\n";
	cin >> a >> b;

	if (a > b) {
		cout << "Mayor: a = " << a;
	}
	else if (b > a) {
		cout << "Mayor: b = " << b;
	}
	else {
		cout << "Iguales a =  " << a << ', '
			 << "b = " << b << '\n';
	}
	return 0;
}

En el siguiente ejemplo se pide un valor numérico del 1 al 7 y se imprime el valor correspondiente de la semana y una advertencia si el valor es diferente del 1 al 7.

#include <iostream>
using namespace std;

int main()
{
	int num;
	cout << "Ingrese un numero de la semana\n\n";
	cin >> num;
	switch (num){
	case 1:
		cout << "Lunes";
		break;
	case 2:
		cout << "Martes";
		break;
	case 3:
		cout << "Miercoles";
		break;
	case 4:
		cout << "Jueves";
		break;
	case 5:
		cout << "Viernes";
		break;
	case 6:
		cout << "Sabado";
		break;
	case 7:
		cout << "Domingo";
		break;
	default:
		cout << "Valor erroneo";
		break;
	}
	return 0;
}

domingo, 6 de septiembre de 2020

Introducción a C++

Estructura básica

Para escribir un programa en C++ se debe considerar la siguiente estructura básica:


// Función principal
int main()
{
   /*
     El código c++ se coloca en esta sección
   */
   return 0;
}

En la primera línea se coloca la referencia a las bibliotecas que empleará el programa. Los comentarios pueden ser de dos tipos:

  • De línea: empleando //
  • De bloque: empleando /* y */

Entrada y salida de datos

Para escribir un programa en C++ se debe considerar la siguiente estructura básica:

#include <iostream>
using namespace std;

int main()
{
   //Declaración de variables
   int num;
   
   //Entrada de datos
   cin >> num;
   
   //Salida de datos
   cout << "Número: " << num;
   return 0;
}

Datos primitivos

  • bool: El tipo de dato bool, tiene un tamaño de 8 bits y un rango entre 0 y 1 (falso o verdadero).
  • int: El tipo de dato int, tiene un tamaño de 32 bits y un rango entre -2147483648 y 2147483647. Este se usa para números enteros (sin decimales). Sus variantes son:
    • short int: Tiene un tamaño de 16 bits y un rango entre -32768 y 32767.
    • unsigned short int: Tiene un tamaño de 16 bits y un rango entre 0 y 65535.
    • unsigned int: Tiene un tamaño de 32 bits y un rango entre 0 y 4294967295.
    • long long int: Tiene un tamaño de 64 bits y un rango entre -9223372775808 y 9223375775807.
    • unsigned long long int: Tiene un tamaño de 64 bits y un rango entre 0 y 2 elevado a la potencia 64.
  • float: Tiene un tamaño de 32 bits, es usado comúnmente en números con 6 o menos cifras decimales. Tiene un rango entre 1,17549*(e^-38) hasta 3,40282*(e^+38).
  • double: Tiene un tamaño de 64 bits, es usado para números de menos de 15 cifras decimales. Tiene un rango entre 2,22507*(e^-308) hasta 1,79769*(e^308).
    • long double: Tiene un tamaño de 96 bits y una precisión de 18 cifras decimales. Tiene un rango entre 3,3621*(e^-4932) hasta 1,18973*(e^4932).
  • char: Son variables de tipo vector que almacenan cualquier caracter y puede estar con o sin signo.
#include <iostream>
using namespace std;

int main()
{
	//Variables
	int num = 2;
	float dec1 = 3.14;
	double dec2 = -2.1213;
	bool val = false;
	char cad = 'a';
	return 0;
}