STL Usando Iteradores de Flujo de Salida o Output Stream Iterator en Visual Studio 2013

Main.cpp

//STL Usando Iteradores de Flujo de Salida o Output Stream Iterator

#include <iostream>
#include <numeric>
#include <vector>
#include <iterator>

using namespace std;


int main()
{
	vector<int> numeros;

	cout << "Introduce una serie de enteros separados por espacios"
		<< " seguido de Ctrl+Z o una letra" << endl;

	istream_iterator<int> entrada{ cin }, entrada_salida;
	ostream_iterator<int> salida{ cout, " " };

	copy(entrada, entrada_salida, back_inserter < vector<int> >(numeros));

	cout << "Tu tecleaste los siguientes valores: " << endl;
	copy(cbegin(numeros), cend(numeros), salida);

	cout << "\nLa suma de esos valores es "
		<< accumulate(cbegin(numeros), cend(numeros), 0) << endl;

	system("pause");
}

STL Usando Iteradores de Flujo de Entradas o Input Stream Iterator en Visual Studio 2013

Main.cpp

//STL Usando Iteradores de Flujo de Entradas o Input Stream Iterator

#include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <iterator>

using namespace std;


int main()
{
	map<string, int> palabras; //con map almacenamos las palabras y la cantidad

	cout << "Introduce algun texto, presiona Enter seguido de un Ctrl+Z"
		<< "entonces introduces Enter para terminar:\n"
		<< endl;

	istream_iterator<string> empiezaFlujo{ cin }; //Stream iterador para empezar
	istream_iterator<string> terminaFlujo; //termina el stream iterador

	while (empiezaFlujo != terminaFlujo)
		palabras[*empiezaFlujo++]++; //incrementa y almacena en un contador de palabras

	//salida de las palabras y la cuenta
	cout << "Aqui estan la cantidad de palabras para el texto que tecleaste: " << endl;
	const int palabrasPorLinea{ 4 };

	int contadorPalabras{};

	cout << setiosflags(ios::left); //justificar la salida a la izquierda

	for (const auto &palabra : palabras)
	{
		cout << setw(15) << palabra.first << " " << setw(5) << palabra.second;

		if (++contadorPalabras % palabrasPorLinea == 0)
			cout << endl;
	}

	cout << endl;
	system("pause");
}

STL Agenda Telefonica Usando Contenedores Map en Visual Studio 2013

Persona.h

//Clase que define el nombre y apellido de una persona

#pragma once

#include <string>
#include <iostream>

using namespace std;

class Persona
{
public:
	
	//constructor
	Persona(const string &nombre = "", const string &apellido = "") : nombrePersona(nombre) , apellidoPersona(apellido) {}

	//constructor Move
	Persona(string &&nombre, string &&apellido) : nombrePersona( move(nombre) ), apellidoPersona( move(apellido) ) {}

	//constructor Move
	Persona(Persona &&persona) :
		nombrePersona( move(persona.nombrePersona) ),
		apellidoPersona( move(persona.apellidoPersona) ) {}

	//Move operador de asignacion
	Persona &operator=(Persona &&persona)
	{
		nombrePersona = move(persona.nombrePersona);
		apellidoPersona = move(persona.apellidoPersona);
	}

	//operador <
	bool operator<(const Persona &p) const
	{
		return (apellidoPersona < p.apellidoPersona ||
			((apellidoPersona == p.apellidoPersona) && (nombrePersona < p.nombrePersona)));
	}

	//Obtener nombre o get
	string getNombre() const
	{
		return nombrePersona + " " + apellidoPersona;
	}


private:

	string nombrePersona ;
	string apellidoPersona;
}; 

Main.cpp

//STL Agenda Telefonica Usando Contenedores Map

#include <iostream>
#include <cstdio>
#include <iomanip>
#include <string>
#include <map>
#include "Persona.h"

using namespace std;

using AgendaTelefonica = map < Persona, string > ;
using Entrada = pair < Persona, string > ;

//Registramos personas
Persona registrarPersona()
{
	string nombre, apellido;
	cout << "Introduce tu nombre: ";
	getline(cin, nombre);
	cout << "Introduce tu apellido: ";
	getline(cin, apellido);

	return Persona{ move(nombre), move(apellido) };
}


Entrada introducirTelefono()
{
	Persona persona{ registrarPersona() };

	string numero;
	cout << "Introduce el numero de telefono para " << persona.getNombre() << " : ";
	getline(cin, numero);

	return make_pair(move(persona), move(numero));
}

//Registramos el telefono
void insertarTelefono(AgendaTelefonica &agenda)
{
	auto pr = agenda.insert(introducirTelefono());

	if (pr.second)
		cout << "Inserto Correctamente" << endl;

	else
	{
		cout << "Entrada coincide con " << pr.first->first.getNombre()
			 << "Y el numero es " << pr.first->second << endl;
	}
}

//lista de contenidos de la agenda telefonica
void listarAgenda(const AgendaTelefonica &agenda)
{
	if (agenda.empty())
	{
		cout << "La agenda esta vacia" << endl;
		return;
	}

	cout << setiosflags(ios::left); //para justificar la salida a la izquierda

	for (const auto &entrada : agenda)
	{
		cout << setw(30) << entrada.first.getNombre()
			<< setw(12) << entrada.second << endl;
	}

	cout << resetiosflags(ios::right); //justificamos a la derecha la salida
}

//Recibimos las entradas de la agenda telefonica
void obtenerEntradas(const AgendaTelefonica &agenda)
{
	Persona persona{ registrarPersona() };
	auto iter = agenda.find(persona);

	if (iter == agenda.end())
	{
		cout << "No encontro a la persona " << persona.getNombre() << endl;
	}

	else
	{
		cout << "El numero para la persona " << persona.getNombre()
			<< " es " << iter->second << endl;
	}
}

//Eliminamos un registro de la agenda telefonica
void eliminarDeAgenda(AgendaTelefonica &agenda)
{
	Persona persona{ registrarPersona() };
	auto iter = agenda.find(persona);

	if (iter == agenda.end())
		cout << "No encontro a la persona " << persona.getNombre() << endl;

	else
	{
		agenda.erase(iter);
		cout << persona.getNombre() << " eliminada" << endl;
	}
}

int main()
{
	AgendaTelefonica agenda;

	char respuesta{};

	while (true)
	{
		cout << "Quieres introducir algo a la agenda(S o N): ";
		cin >> respuesta;

		while (cin.get() != '\n'); //ignora la entrada de una nueva linea

		if (toupper(respuesta) == 'N')
			break;

		if (toupper(respuesta) != 'S')
		{
			cout << "Respuesta invalida, intentalo de nuevo" << endl;
			continue;
		}

		insertarTelefono(agenda);
	}

	//Consultamos la agenda
	while (true)
	{
		cout << "\nEscoge una de las siguientes opciones:" << endl
		<< "A - Agrega un registro  E - Elimina un Registro  B - Buscar Registro" << endl
			<< "L - Listar agenda   C - Cerrar programa" << endl;

		cin >> respuesta;

		while (cin.get() != '\n'); //ignoramos la nueva linea

		switch (toupper(respuesta))
		{
		case 'A':
			insertarTelefono(agenda);
			break;

		case 'B':
			obtenerEntradas(agenda);
			break;

		case 'E':
			eliminarDeAgenda(agenda);
			break;

		case 'L':
			listarAgenda(agenda);
			break;

		case 'C':
			return 0;

		default:
			cout << "Opcion invalida. Intentalo de nuevo" << endl;
			break;
		}
	}
	
	system("pause");
	return 0;
}

STL Almacenando Tuplas en un Array en Visual Studio 2013

Main.cpp

//STL Almacenando Tuplas en un Array

#include <iostream>
#include <array>
#include <tuple>
#include <string>
#include <iomanip>

using namespace std;

const size_t maxRegistros{ 100 };
using Registro = <tuple  int, string, string, int> ;
using Registros = <array  Registro, maxRegistros> ;

//Lista de contenidos de Registros en un Array
void listarRegistros(const Registros &gentes)
{
 const size_t ID{}, nombre{ 1 }, apellido{ 2 }, edad{ 3 };
 cout << setiosflags(ios::left);
 Registro vacio;

 for (const auto &registro : gentes)
 {
  if (registro == vacio)
   break; //en caso de que no este lleno

  cout << "ID: " << setw(6) << get<ID>(registro)
   << "Nombre: " << setw(25)
   << (get<nombre>(registro) +" " + get<apellido>(registro))
   << "Edad: " << setw(5) << get<edad>(registro) << endl;
 }
}




int main()
{
 Registros personal{
  Registro{ 1001, "Depredador1220", "Admin", 26 },
  Registro{ 1002, "Kenny", "Ruiz", 26 },
  Registro{ 1003, "Mario", "Bros", 30 },
  Registro{ 1004, "James", "Bond", 44 }
 };

 personal[4] = make_tuple(1005, "Luffy", "Monkey D.", 22);
 personal.at(5) = Registro{ 1006, "Goku", "Kakaroto", 50 };

 listarRegistros(personal);

 system("pause");
}

STL Usando el Contenedor Cola en Visual Studio 2013

Main.cpp

//STL Usando contenedor Cola

#include <iostream>
#include <queue>
#include <string>

using namespace std;

int main()
{
	queue<string> frases;
	string frase;
	
	cout << "Introduce una o mas frases. Presiona Enter para terminar" << endl;

	while (true)
	{
		getline(cin, frase);

		if (frase.empty())
		{
			break;
		}

		frases.push(frase);
	}

	cout << "Hay " << frases.size() << " frases en el contenedor cola\n" << endl;

	cout << "Las frases que tu colocaste son: " << endl;

	while (!frases.empty())
	{
		cout << frases.front() << endl;
		frases.pop();
	}

	system("pause");
}

STL Trabajando con Listas en Visual Studio 2013

Main.cpp

//STL Trabajando con Listas

#include <iostream>
#include <list>
#include <string>
#include <functional>

using namespace std;

void listarTodo(const list<string> &cadena)
{
	for (auto &s : cadena)
	{
		cout << s << endl;
	}
}

int main()
{
	list<string> texto;

	//Lee los datos
	cout << "Introduce 5 lineas de texto. Solo presiona Enter cuando termines: " << endl;
	string sentencia;

	while (getline(cin, sentencia, '\n'), !sentencia.empty())
		texto.push_front(sentencia);

	cout << "Tu texto en orden inverso: " << endl;
	listarTodo(texto);

	texto.sort();

	cout << "\nTu texto en secuencia ascendente: " << endl;
	listarTodo(texto);

	texto.sort(greater<>());

	cout << "\nTu texto en secuencia descendente: " << endl;
	listarTodo(texto);

	system("pause");
}

STL Usando Colas de Doble Terminacion en Visual Studio 2013

Main.cpp

//STL Usando Colas de Doble Terminacion

#include <iostream>
#include <deque>

//para usar sort<T>()
#include <algorithm>

//para usar accumulate<T>()
#include <numeric>

#include <functional>

using namespace std;

int main()
{
	deque<int> datos;

	//Lee los datos
	cout << "Introduce una serie de enteros separados por espacios."
		<< " Introduce 0 para terminar." << endl;

	int valor{};

	while (cin >> valor, valor != 0)
		datos.push_front(valor);

	//salida de los datos
	cout << endl << "Los valores que tu introduciste del ultimo al primero son: " << endl;
	
	for (const auto &n : datos)
	{
		cout << n << "  ";
	}

	cout << endl;

	//La salida de los datos usando un iterator en reversa
	cout << endl
		<< "En orden inverso los valores que tu introduciste" << endl;

	for (auto revIter = crbegin(datos); revIter != crend(datos); ++revIter)
		cout << *revIter << "  ";

	cout << endl;

	//ordena los datos en secuencia descendente
	cout << endl
		<< "Los valores del mayor al menor introducidos son: " << endl;

	//ordena los elementos
	sort(begin(datos), end(datos), greater<>());

	for (const auto &n : datos)
		cout << n << "  ";
	cout << endl;

	//Calcula la suma de los elementos
	cout << endl
		<< "La suma de los elementos en la cola es: "
		<< accumulate(cbegin(datos), cend(datos), 0) << endl;

	system("pause");
}

STL Usando Contenedores Array en Visual Studio 2013

Main.cpp

//STL Usando Contenedores Array

#include <iostream>
#include <iomanip>
#include <array>
#include <numeric>

using namespace std;
using std::array;

//Lista de Valores de un Contenedor Array
template<class T, size_t N>
void listaValores(const array<T, N> &datos)
{
	const int valores_por_linea{ 6 };
	int contador{};
	for (const auto &valor : datos)
	{
		cout << setw(14) << valor;

		if (++contador % valores_por_linea == 0)
		{
			cout << endl;
		}

		cout << endl;
	}
}


int main()
{
	//Creamos la serie fibonacci
	const size_t N{ 20 };
	array<long, N> fibonacci{ 1L, 1L };

	for (size_t i{ 2 }; i < fibonacci.size(); ++i)
	{
		fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
	}

	cout << "La Serie Fibonacci es: " << endl;

	listaValores(fibonacci);

	array<long, N> numeros;
	numeros.fill(99L);
	fibonacci.swap(numeros);
	cout << endl << "Despues de intercambiar el contenido de fibonacci" << endl;
	listaValores(fibonacci);

	//creamos una serie para pi/4
	array<double, 120>series;
	double factor{ -1.0 };

	for (size_t x{}; x < series.size(); ++x)
	{
		factor *= -1.0;
		series[x] = factor / (2 * x + 1);
	}

	cout << endl << "Serie para PI es: " << endl;
	listaValores(series);

	double resultado{ accumulate(cbegin(series), cend(series), 0.0) };

	cout << "La serie de sumas converge lentamente a pi / 4. La suma x 4 es: "
		<< 4.0 * resultado << endl;

	system("pause");
}

Almacenando Punteros de Objetos a un Vector en Visual Studio 2013

Persona.h

//Clase que define el nombre y apellido de una persona

#pragma once

#include <cstring>
#include <iostream>

using namespace std;

class Persona
{
public:
	
	//constructor
	Persona(const char *nombre, const char *apellido)
	{
		iniciarNombre(nombre, apellido);
	}

	//constructor copia
	Persona(const Persona &p)
	{
		iniciarNombre(p.nombrePersona, p.apellidoPersona);
	}

	//Mover Constructor
	Persona(Persona &&p)
	{
		nombrePersona = p.nombrePersona;
		apellidoPersona = p.apellidoPersona;

		//reseteamos el puntero del objeto rvalue para prevenir la destruccion
		p.nombrePersona = nullptr;
		p.apellidoPersona = nullptr;
	}

	//Destructor
	virtual ~Persona()
	{
		delete[] nombrePersona;
		delete[] apellidoPersona;
	}

	//Operador de asignacion copia
	Persona &operator=(const Persona &p)
	{
		//Tratamos con p = p en situaciones de asignacion
		if (&p != this)
		{
			delete[] nombrePersona;
			delete[] apellidoPersona;
			iniciarNombre(p.nombrePersona, p.apellidoPersona);
		}

		return *this;
	}

	//operador de asignacion mover
	Persona &operator=(Persona &&p)
	{
		//tratamos con p = p en situaciones de asignacion
		if (&p != this)
		{
			//liberamos la memoria actual
			delete[] nombrePersona;
			delete[] apellidoPersona;
			nombrePersona = p.nombrePersona;
			apellidoPersona = p.apellidoPersona;
			p.nombrePersona = nullptr;
			p.apellidoPersona = nullptr;
		}

		return *this;
	}

	//operador <
	bool operator<(const Persona &p) const
	{
		int resultado{ strcmp(apellidoPersona, p.apellidoPersona) };
		return (resultado < 0 || resultado == 0 && strcmp(nombrePersona, p.nombrePersona) < 0);
	}

	//mostrar los datos de la persona
	void mostrarPersona() const
	{
		cout << nombrePersona << " " << apellidoPersona << endl;
	}

private:

	char *nombrePersona{};
	char *apellidoPersona{};

	//funcion privada para evitar la duplicacion del codigo
	void iniciarNombre(const char *nombre, const char *apellido)
	{
		size_t tam{ strlen(nombre) + 1 };
		nombrePersona = new char[tam];
		strcpy_s(nombrePersona, tam, nombre);
		tam = strlen(apellido) + 1;
		apellidoPersona = new char[tam];
		strcpy_s(apellidoPersona, tam, apellido);
	}
}; 

Main.cpp

//Almacenando punteros a objetos en un Vector.

#include <iostream>
#include <vector>
#include <memory>
#include "Persona.h"

using namespace std;
using std::vector;
using std::unique_ptr;
using std::make_unique;


int main()
{
	//Vector puntero de objetos Persona
	vector<unique_ptr<Persona>> gente;
	const size_t tamMax{ 50 };
	char nombrePersona[tamMax];
	char apellidoPersona[tamMax];

	//Entrada de todas las personas
	while (true)
	{
		cout << "Introduce el nombre o presiona enter para terminar: ";
		cin.getline(nombrePersona, tamMax, '\n');

		if (strlen(nombrePersona) == 0)
			break;

		cout << "Introduce el apelliido: ";
		cin.getline(apellidoPersona, tamMax, '\n');
		gente.push_back(make_unique<Persona>(nombrePersona, apellidoPersona));
	}

	//Salida del contenido del vector 
	cout << endl;

	for (const auto &p : gente)
		p->mostrarPersona();
	
	system("pause");
}

Almacenando objetos en un vector en Visual Studio 2013

Persona.h

//Clase que define el nombre y apellido de una persona

#pragma once

#include <cstring>
#include <iostream>

using namespace std;

class Persona
{
public:
	
	//constructor
	Persona(const char *nombre, const char *apellido)
	{
		iniciarNombre(nombre, apellido);
	}

	//constructor copia
	Persona(const Persona &p)
	{
		iniciarNombre(p.nombrePersona, p.apellidoPersona);
	}

	//Mover Constructor
	Persona(Persona &&p)
	{
		nombrePersona = p.nombrePersona;
		apellidoPersona = p.apellidoPersona;

		//reseteamos el puntero del objeto rvalue para prevenir la destruccion
		p.nombrePersona = nullptr;
		p.apellidoPersona = nullptr;
	}

	//Destructor
	virtual ~Persona()
	{
		delete[] nombrePersona;
		delete[] apellidoPersona;
	}

	//Operador de asignacion copia
	Persona &operator=(const Persona &p)
	{
		//Tratamos con p = p en situaciones de asignacion
		if (&p != this)
		{
			delete[] nombrePersona;
			delete[] apellidoPersona;
			iniciarNombre(p.nombrePersona, p.apellidoPersona);
		}

		return *this;
	}

	//operador de asignacion mover
	Persona &operator=(Persona &&p)
	{
		//tratamos con p = p en situaciones de asignacion
		if (&p != this)
		{
			//liberamos la memoria actual
			delete[] nombrePersona;
			delete[] apellidoPersona;
			nombrePersona = p.nombrePersona;
			apellidoPersona = p.apellidoPersona;
			p.nombrePersona = nullptr;
			p.apellidoPersona = nullptr;
		}

		return *this;
	}

	//operador <
	bool operator<(const Persona &p) const
	{
		int resultado{ strcmp(apellidoPersona, p.apellidoPersona) };
		return (resultado < 0 || resultado == 0 && strcmp(nombrePersona, p.nombrePersona) < 0);
	}

	//mostrar los datos de la persona
	void mostrarPersona() const
	{
		cout << nombrePersona << " " << apellidoPersona << endl;
	}

private:

	char *nombrePersona{};
	char *apellidoPersona{};

	//funcion privada para evitar la duplicacion del codigo
	void iniciarNombre(const char *nombre, const char *apellido)
	{
		size_t tam{ strlen(nombre) + 1 };
		nombrePersona = new char[tam];
		strcpy_s(nombrePersona, tam, nombre);
		tam = strlen(apellido) + 1;
		apellidoPersona = new char[tam];
		strcpy_s(apellidoPersona, tam, apellido);
	}
};

Main.cpp

//Almacenando objetos en un Vector.

#include <iostream>
#include <vector>
#include "Persona.h"

using namespace std;
using std::vector;


int main()
{
	//Vector de objetos Persona
	vector<Persona> gente;
	const size_t tamMax{ 50 };
	char nombrePersona[tamMax];
	char apellidoPersona[tamMax];

	//Entrada de todas las personas
	while (true)
	{
		cout << "Introduce el nombre o presiona enter para terminar: ";
		cin.getline(nombrePersona, tamMax, '\n');

		if (strlen(nombrePersona) == 0)
			break;

		cout << "Introduce el apelliido: ";
		cin.getline(apellidoPersona, tamMax, '\n');
		gente.emplace_back(Persona(nombrePersona, apellidoPersona));
	}

	//Salida del contenido del vector usando un iterador
	cout << endl;
	auto iter = cbegin(gente);

	while (iter != cend(gente))
	{
		iter->mostrarPersona();
		++iter;
	}

	system("pause");
} 

STL Vector en Visual Studio 2013

Main.cpp

//Explorando el tamaño y capacidad de un vector

#include <iostream>
#include <vector>

using namespace std;
using std::vector;

//funcion template que muestra el tamaño y la capacidad de cualquier vector
template<class T>
void infoLista(const vector<T> &v)
{
 cout << "Capacidad del contenedor: " << v.capacity()
  << " Tamanio del contenedor: " << v.size() << endl;
}


int main()
{
 //creacion del vector basico
 vector<double> datos;
 infoLista(datos);

 datos.reserve(100);

 cout << "Despues de llamar a reserve(100): " << endl;
 infoLista(datos);

 //crea un vector con 10 elementos y los inicializa
 vector<int> numeros(10, -1);

 cout << "Los valores iniciales son: ";

 //se puede usar el rango basado en vector, usando for mejorados
 for (auto n : numeros)
 {
  cout << " " << n;
 }

 cout << endl << endl;

 //observar como se agregan los elementos que afectan la capacidad de incremento
 auto viejaCapacidad = numeros.capacity();
 auto nuevaCapacidad = viejaCapacidad;

 infoLista(numeros);

 for (int i{}; i < 1000; i++)
 {
  numeros.push_back(2 * i);
  nuevaCapacidad = numeros.capacity();

  //solo la salida cuando la capacidad incrementa
  if (viejaCapacidad < nuevaCapacidad)
  {
   viejaCapacidad = nuevaCapacidad;
   infoLista(numeros);
  }
 }

 system("pause");
}

Texto con efecto parpadeante en unity 5+

1.- Creamos un nuevo proyecto en 2D

2.- Creamos un nuevo texto dandole en GameObject -> UI -> Text, y le colocamos un nombre cualquiera, esto nos agregara tambien un canvas y un EventSystem.

3.- Ahora que lo hemos creado podemos ponerlo en cualquier posicion, para ello si queremos le damos en el inspector en el icono de un cuadro con la posicion y podemos elegir su posicion, con esto aseguramos que en nuestra ventana de Game la posicion sea relativa y no cambien tambien le podemos dar la tecla alt o shitf y cambian nuestras opciones.

4.- Por el momento dejamos las opciones del inspector como estan, no cambiamos nada, bien ahora crearemos un C# Script el cual nos realizara el efecto de parpadeo lo llamaremos TextoParpadeante. Abrimos el Script en Monodevelop dando doble clic al script, y agregamos el siguiente codigo.

TextoParpadeante.cs

using UnityEngine;
using System.Collections;

//agregamos nuevos using para poder usar el New GUI
using UnityEngine.UI;
using UnityEngine.EventSystems;

public class TextoParpadeante : MonoBehaviour {

 //Agregamos las variables de Texto y Strings
 Text textoParpadeante;
 string textoQueParpadea = "Depredador1220";
 string textoEnBlanco = "";
 string textoEstatico = "NO PARPADEA";

 //Agregamos una bandera que sera nuestro identificador para cambiar el texto
 bool estaParpadeando = true;
 
 void Start () 
 {
  //obtenemos el componente del texto
  textoParpadeante = GetComponent<text>();

  //llamamos al coroutine de la funcion de TextoParpadeo
  StartCoroutine(TextoParpadeo());

  //llamamos a la otra funcion para saber si se detuvo el tiempo de parpadeo
  StartCoroutine(DetenerParpadeo());
 }

 //funcion para que parpadee el texto
 public IEnumerator TextoParpadeo()
 {
  //el parpadeo sera infinito hasta que termine la condicion dependiendo tu eleccion
  while(estaParpadeando)
  {
   //Establecemos nuestro texto en blanco
   textoParpadeante.text = textoEnBlanco;

   //mostramos el texto en blanco por 0.5 segundos
   yield return new WaitForSeconds(.5f);

   //mostramos nuestro texto en mi caso Depredador1220 por otros 0.5 segundos
   textoParpadeante.text = textoQueParpadea;
   yield return new WaitForSeconds(.5f);
  }
 }

 //funcion para detener el parpadeo
 public IEnumerator DetenerParpadeo()
 {
  //Esperamos por 5 segundos
  yield return new WaitForSeconds(5f);

  //detenemos el parpadeo
  estaParpadeando = false;

  //mostramos diferentes textos para probar
  textoParpadeante.text = textoEstatico;
 }
} 

5.-Ahora con nuestro Script Terminado, podemos cambiarle las propiedades de nuestro texto como el color, tamaño, posicion, fuente etc.

6.- Ahora arrastramos nuestro script hacia el texto para asignarselo.

7.- Ahora solo le damos reproducir para obtener nuestro resultado.

Practica siempre para ir mejorando, la repetición y la constancia nos ayudan a mejorar, recuerda cada vez lo harás mejor, si te equivocas esta bien, permitirse equivocarse es la clave de mejora continua, así que permítete equivocarte mas seguido.

Si te gusta este sitio y deseas que esto continué vivo tu apoyo sera importante, puedes dar clic en la publicidad si lo deseas o puedes donar algo en Patreon si puedes permitírtelo, con esto el proyecto empezara a tener un objetivo y dejara de navegar sin rumbo y empezara a convertirse en una comunidad que ayudara unos a los otros, saludos y excelente día.

Agregando fuentes a un texto en unity 5+

1.- Creamos un nuevo proyecto en 2D

2.- Creamos un nuevo texto dandole en GameObject -> UI -> Text, y le colocamos un nombre cualquiera, esto nos agregara tambien un canvas y un EventSystem.

3.- Ahora que lo hemos creado podemos ponerlo en cualquier posicion, para ello si queremos le damos en el inspector en el icono de un cuadro con la posicion y podemos elegir su posicion, con esto aseguramos que en nuestra ventana de Game la posicion sea relativa y no cambien tambien le podemos dar la tecla alt o shitf y cambian nuestras opciones.

4.- En las propiedades del texto, podemos cambiar el texto si lo deseamos, tambien podemos cambiar el tamaño, la fuente y la alineacion de nuestro texto y el color por supuesto.

5.- Creamos una carpeta y la llamaremos Font o como quieran, dentro de la carpeta meteremos la fuente de tipo fuente.ttf, coloco un link donde pueden descargar muchas fuentes.ttf

fuentes

 6.- Ahora nos vamos al inspector y le damos en Font y le damos sobre el pequeño circulo y nos aparecera una ventana con nuestras fuentes escogemos una para poder obtener el resultado deseado.

7.- Aqui el resultado de este ejemplo.

Practica siempre para ir mejorando, la repetición y la constancia nos ayudan a mejorar, recuerda cada vez lo harás mejor, si te equivocas esta bien, permitirse equivocarse es la clave de mejora continua, así que permítete equivocarte mas seguido.

Si te gusta este sitio y deseas que esto continué vivo tu apoyo sera importante, puedes dar clic en la publicidad si lo deseas o puedes donar algo en Patreon si puedes permitírtelo, con esto el proyecto empezara a tener un objetivo y dejara de navegar sin rumbo y empezara a convertirse en una comunidad que ayudara unos a los otros, saludos y excelente día.

Agregando Texto y poniendo un efecto Unity 5+

1.- Creamos un nuevo proyecto en 2D

2.- Creamos un nuevo texto dandole en GameObject -> UI -> Text, y le colocamos un nombre cualquiera, esto nos agregara tambien un canvas y un EventSystem.

3.- Ahora que lo hemos creado podemos ponerlo en cualquier posicion, para ello si queremos le damos en el inspector en el icono de un cuadro con la posicion y podemos elegir su posicion, con esto aseguramos que en nuestra ventana de Game la posicion sea relativa y no cambien tambien le podemos dar la tecla alt o shitf y cambian nuestras opciones.

4.- En las propiedades del texto, podemos cambiar el texto si lo deseamos, tambien podemos cambiar el tamaño, la fuente y la alineacion de nuestro texto y el color por supuesto.

 

5.-  Ahora que hemos hecho esto, podemos agregarle un efecto a nuestras letras, para ello nos vamos en Add Component -> UI -> Efect -> outline

6.- Podemos cambiar las propiedades de nuestro outliner si lo deseamos en el inspector.

7.- Nuestro resultado quedara algo como esto, ya habremos insertado nuestro texto y le habremos dado un efecto.

Smart Pointer - unique_ptr en Visual Studio 2013

Los smart pointer o punteros inteligentes es un tipo abstracto de datos que simula el comportamiento de un puntero normal pero que añade nuevas caracteristicas, como recolector de basura automatico y comprobador de limites.

El unique_ptr es un puntero inteligente que usamos cuando se desea un puntero a un objeto que se reclama cuando ese unico puntero es destruido.

A continuacion un ejemplo

Main.cpp

//Punteros inteligentes o smart pointers 
//usando unique_ptr
#include <iostream>
#include <memory>

using namespace std;

//funcion prototipo
unique_ptr<double> triple(double);

int main()
{
 double num{5.0};

 unique_ptr<double> ptr{};
 ptr = triple(num);

 cout << "Tres veces el numero = " << 3.0 * num << endl;
 cout << "Resultado: " << *ptr << endl;

 system("pause");
}

unique_ptr<double> triple(double datos)
{
 unique_ptr<double> resultado{ new double{} };
 *resultado = 3.0 * datos;
 return resultado;
}