[HttpPost]
        public ActionResult Create(PersonModels person)
        {
            try
            {
                // TODO: Add insert logic here
                //Adding to database and holding the response in the viewbag.
                string strInsertion = ConnectionModels.insertPerson(person);
                ViewBag.InsertionResult = strInsertion;
 
                return RedirectToAction("Index");
            }
            catch
            {
                return View("Index");
            }
        }
 

public ActionResult Index()
        {
            return View();
        }
 

<div>
    <label>
       @ViewBag.InsertionResult
    </label>
</div>
 

DELIMITER |
 
CREATE EVENT Event_Log_Counter
ON SCHEDULE
	EVERY 15 SECOND
	STARTS '2017-05-12 15:30:00'
    ENDS '2017-05-12 16:30:00'
DO
BEGIN
	DECLARE cValueCounter BIGINT UNSIGNED;
 
    SELECT cValueCounter := Counter FROM Log_Counter;
    SET cValueCounter := cValueCounter + 1;
 
    UPDATE log_counter
    SET Counter = cValueCounter;
END |
 
DELIMITER ;
 

private: System::Void button3_Click(System::Object^  sender, System::EventArgs^  e) {
        std::vector<Mat> images;
        std::vector<int> labels;
 
        std::vector<cv::String> filenames;
        glob("Dataface/*.jpg", filenames, false);
 
        if (filenames.size() == (size_t)0) {
            MessageBox::Show("La carpeta está vacía.", "Error", MessageBoxButtons::OK, MessageBoxIcon::Error);
            return;
        }
 
        for (size_t i = 0; i < filenames.size(); i++) {
            images.push_back(imread(filenames[i]));
            labels.push_back((int)i);
        }
 
        Ptr<FaceRecognizer> model = createEigenFaceRecognizer();
 
        model->train(images, labels);
 
        Mat img = imread("C:\\Users\\Germán Aguilera\\Desktop\\Christina.jpg");
 
        int prediction = model->predict(img);
 
        //MessageBox::Show(prediction.ToString());
 
        //rModel = &model;
 
        MessageBox::Show("El programa ya ha sido entrenado.", "Reconocimiento facial", MessageBoxButtons::OK, MessageBoxIcon::Information);
    }
 

int prediction = model->predict(img);
 

model->train(images, labels);
 

#pragma once
 
template<class T>
class Nodo {
private:
	Nodo<T>* siguiente;
	Nodo<T>* anterior;
	T clave;
public:
	inline Nodo();
	inline Nodo(T clave);
 
	inline Nodo<T>* getSiguiente();
	inline Nodo<T>* getAnterior();
	inline T getClave();
 
	inline void setSiguiente(Nodo<T>* siguiente);
	inline void setAnterior(Nodo<T>* anterior);
	inline void setClave(T clave);
};
 

#include "Nodo.h"
 
template <class T>
inline Nodo<T>::Nodo() {
	siguiente = nullptr;
	anterior = nullptr;
	clave = 0;
}
 
template <class T>
inline Nodo<T>::Nodo(T clave) {
	siguiente = nullptr;
	anterior = nullptr;
	this->clave = clave;
}
 
template <class T>
inline Nodo<T>* Nodo<T>::getSiguiente() {
	return siguiente;
}
 
template <class T>
inline Nodo<T>* Nodo<T>::getAnterior() {
	return anterior;
}
 
template <class T>
inline T Nodo<T>::getClave() {
	return clave;
}
 
template <class T>
inline void Nodo<T>::setAnterior(Nodo<T>* anterior) {
	this->anterior = anterior;
}
 
template <class T>
inline void Nodo<T>::setSiguiente(Nodo<T>* siguiente) {
	this->siguiente = siguiente;
}
 
template <class T>
inline void Nodo<T>::setClave(T clave) {
	this->clave = clave;
}
 

#pragma once
#include "Nodo.h"
 
template <class T>
class ListaDoble {
private:
	Nodo<T>* inicio;
public:
	inline ListaDoble();
 
	void agregar(Nodo<T>* n);
	void eliminar(Nodo<T>* n);
	void listar();
 
	inline Nodo<T>* getInicio();
};
 

#include "ListaDoble.h"
 
template <class T>
inline ListaDoble<T>::ListaDoble() {
	inicio = nullptr;
}
 
template <class T>
void ListaDoble<T>::agregar(Nodo<T>* n) {
	n->setSiguiente(inicio);
 
	if (inicio != nullptr) {
		inicio->setAnterior(n);
	}
 
	n->setAnterior(nullptr);
	inicio = n;
}
 
template <class T>
void ListaDoble<T>::eliminar(Nodo<T>* n) {
	if (n->getAnterior() != nullptr) {
		n->getAnterior()->setSiguiente(n->getSiguiente());
	} else {
		inicio = n;
	}
 
	if (n->getSiguiente() != nullptr) {
		n->getSiguiente()->setAnterior(n->getAnterior());
	}
 
	delete n;
}
 
template <class T>
inline Nodo<T>* ListaDoble<T>::getInicio() {
	return inicio;
}
 
template <class T>
void ListaDoble<T>::listar() {
	for (Nodo<T>* aux = inicio; aux != nullptr; aux = aux->getSiguiente()) {
		cout << "Clave: " << aux->getClave() << endl;
	}
}
 

#pragma once
#include "ListaDoble.h"
 
#define TAM 701
 
template <class T>
class TablaHash {
private:
	ListaDoble<T>* H[TAM];
public:
	TablaHash();
 
	void agregar(Nodo<T>* n);
	void eliminar(Nodo<T>* n);
	Nodo<T>* buscar(T clave);
 
	inline int h(int clave);
 
	void listar();
};
 

#include "TablaHash.h"
 
template<class T>
TablaHash<T>::TablaHash() {
	for (int h = 0; h < TAM; h++) {
		H[h] = nullptr;
	}
}
 
template<class T>
inline int TablaHash<T>::h(int clave) {
	return (clave % TAM);
}
 
template<class T>
void TablaHash<T>::agregar(Nodo<T>* n) {
	int slot = h((int)n->getClave());
 
	if (H[slot] == nullptr) {
		H[slot] = new ListaDoble<T>;
	}
 
	H[slot]->agregar(n);
}
 
template <class T>
Nodo<T>* TablaHash<T>::buscar(T clave) {
	int slot = h((int)clave);
 
	if (H[slot] != nullptr) {
		for (Nodo<T>* aux = H[slot]->getInicio(); aux != nullptr; aux = aux->getSiguiente()) {
			if (aux->getClave() == clave) {
				return aux;
			}
		}
	}
 
	return nullptr;
}
 
template <class T>
void TablaHash<T>::eliminar(Nodo<T>* n) {
	int slot = h((int)n->getClave());
	Nodo<T>* aux = buscar(n->getClave());
 
	if (aux != nullptr) {
		H[slot]->eliminar(aux);
	}
 
	if (H[slot]->getInicio() == nullptr) {
		H[slot] = nullptr;
		delete H[slot];
	}
}
 
template <class T>
void TablaHash<T>::listar() {
	for (int i = 0; i < TAM; i++) {
		if (H[i] != nullptr) {
			H[i]->listar();
		}
	}
}
 

#include <iostream>
#include "TablaHash.h"
 
using namespace std;
 
int main() {
	TablaHash<int> myHashTable;
 
	Nodo<int>* nodo1 = new Nodo<int>(25);
	Nodo<int>* nodo2 = new Nodo<int>(35);
	Nodo<int>* nodo3 = new Nodo<int>(45);
 
 
	return 0;
}
 

- Error	LNK2019	unresolved external symbol "public: __thiscall TablaHash<int>::TablaHash<int>(void)" (??0?$TablaHash@H@@QAE@XZ) referenced in function _main	
- Error	LNK2019	unresolved external symbol "public: __thiscall Nodo<int>::Nodo<int>(int)" (??0?$Nodo@H@@QAE@H@Z) referenced in function _main	

- Error	LNK1120	2 unresolved externals

#include <iostream>
#include <windows.h> //Para la función Sleep.
 
int main() {
     for(int h = 0;;h++) {
          std::cout << "El valor de H es: " << h << std::endl;
          Sleep(1000);
     }
 
     return 0;
}
 

#include <iostream>
#include <fstream>
#include <string>
 
using namespace std;
 
//Función que devuelve una línea con cada espacio en blanco con un guión bajo
string reemplazar(string linea);
 
int main() {
    //Creación del archivo.
    fstream archivo("archivo.txt", ios::in | ios::out);
    //Variable para almacenar cada línea del archivo.
    string linea;
    //Variable para reemplazar todo lo que está en el archivo.
    string dArchivo = "";
 
    //Comprobando que el archivo exista.
    if(!archivo) {
        cerr << "Error: El archivo no existe." << endl;
        return -1;
    }
 
    //Leyendo cada línea del fichero.
    while(!archivo.eof()) {
        //Obteniendo línea por línea desde el archivo.
        getline(archivo, linea);
 
        //Almacenando las líneas con los guiones bajos ya reemplazados.
        dArchivo += reemplazar(linea) + "\n";
    }
 
    //Sobreescribiendo el archivo con los guiones bajos ya establecidos.
    archivo << dArchivo;
 
    //Cerrando el archivo.
    archivo.close();
 
    return 0;
}
 
//Implementando el método para reemplazar los espacios en blanco por un guión bajo.
string reemplazar(string linea) {
    //Nueva línea
    string nLinea = "";
 
    //Sustituyendo cada espacio en blanco con un guión bajo.
    for(unsigned int h = 0; h < linea.length(); h++) {
        if(linea[h] == ' ') {
            nLinea[h] += '_';
        } else {
            nLinea[h] += linea[h];
        }
    }
 
    return nLinea;
}
 

function calculate() {
				//Value taken in order to calculate y's value into the function from the textbox
				var x = parseInt(document.getElementById('f_Value').value); 
 
				//L0
				var l_0 = ((x - 50)*(x - Math.pow(3,4))*(x - Math.pow(1,6)))/((12 - 50) * (12 - Math.pow(3,4)) * (12 - Math.pow(1,6)));
				//L1
				var l_1 = ((x - 12)*(x - Math.pow(3,4))*(x - Math.pow(1,6)))/((50 - 12) * (50 - Math.pow(3,4)) * (50 - Math.pow(1,6)));
				//L2
				var l_2 = ((x - 12)*(x - 50)*(x - Math.pow(1,6)))/((Math.pow(3,4) - 12) * (Math.pow(3,4) - 50) * (Math.pow(3,4) - Math.pow(1,6)));
				//L3
				var l_3 = ((x - 12)*(x - 50)*(x - Math.pow(3,4)))/((Math.pow(1,6) - 12) * (Math.pow(1,6)- 50) * (Math.pow(1,6) - Math.pow(3,4)));
 
				//Final value after calculating it inside our function. 
				var v_Function = (2 * l_0) + (4 * l_1) + (100 * l_2) + (700 * l_3); 
 
				alert(l_2);
				//alert("The Y value for " + x + " is: " + v_Function);
			}
 

#include <iostream>
#include <sstream>
#include <stdio.h>
 
using namespace std;
 
class Cliente
{
public:
 
    Cliente(string nombre, string apellido, long int cedula, short int edad);
 
     // funciones de la clase.
     // tipo de dato a retornar/ nombre / (lista de parametros),.
 
     string getNombre();
     string getApellido();
     long int getCedula();
     short int getEdad();
     string toString();
     void setNombre(string nombre);
     void setApellido(string apellido);
     void setCedula(long int cedula);
     void setEdad(short int edad);
     string convertirCedula(long int cedula);
     string convertirEdad(short int edad);
 
private:
 
    string nombre, apellido;
    long int cedula;
    short int edad;
};
 
// Constructor, fuera de la clase.
Cliente::Cliente(string nombre, string apellido, long int cedula, short int edad)
{
    this->nombre=nombre;
    this->apellido = apellido;
    this->cedula = cedula;
    this->edad = edad;
}
 
string Cliente::getApellido()
{
    return apellido;
}
 
string Cliente::getNombre()
{
 
    return nombre;
}
 
long int Cliente::getCedula()
{
    return cedula;
}
 
short int Cliente::getEdad()
{
    return edad;
}
 
void Cliente::setNombre(string nombre)
{
    this->nombre = nombre;
}
 
void Cliente::setApellido(string apellido)
{
    this->apellido = apellido;
}
 
void Cliente::setCedula(long int cedula)
{
 
    this->cedula = cedula;
}
 
void Cliente::setEdad(short int edad)
{
    this->edad = edad;
}
 
string Cliente::toString()
{
 
    string total;
 
    string cedulaTrans, edadTrans;
 
    cedulaTrans = convertirCedula(cedula);
    edadTrans = convertirEdad(edad);
 
    total = nombre + "\n" + apellido + "\n" + cedulaTrans + "\n" + edadTrans;
 
    return total;
}
 
string Cliente::convertirCedula(long int cedula)
{
      stringstream flujo;
 
      flujo << cedula;
 
      return (flujo.str());
}
 
string Cliente::convertirEdad(short int edad)
{
    stringstream flujo;
 
    flujo << edad;
 
    return (flujo.str());
 
}
 
class Banco
{
public:
 
    Banco();
    string agregar(Cliente c);
    string mostrar();
 
private:
 
    Cliente c[20];
    int cont;
};
 
Banco::Banco()
{
    this->cont=0;
 
}
 
string Banco::agregar(Cliente aux){
 
    if(cont<20)
    {
        c[cont]=aux;
        cont++;
        return "Cliente agregado satisfactoriamente";
    }
 
    return "Banco lleno. No se puede agregar mas personas";
 
}
 
string Banco::mostrar()
{
    string x;
 
    for(int i=0; i<cont; i++)
    {
        x = x + c[i].toString();
    }
 
    return x;
 
}
 
int leerentero(string sms)
{
    int aux;
 
    cout << sms;
    cin >> aux;
 
    return aux;
 
}
 
Cliente leercliente()
{
       string nombre;
       string apellido;
       short int edad;
       long int cedula;
 
       cout << "\nIngrese Nombre: " << endl;
       cin.clear();
       fflush(stdin);
       getline(cin, nombre);
       cout << "\nIngrese Apellido: " << endl;
       cin.clear();
       fflush(stdin);
       getline(cin, apellido);
       cout << "\nIngrese Cedula: " << endl;
       cin >> cedula;
       cout << "\nIngrese Edad: " << endl;
       cin >> edad;
 
       Cliente aux(nombre, apellido, cedula, edad);
       return aux;
 
}
 
int main()
{
    Banco b;
    int opc;
    do
    {
 
        cout << "\n[1]Agregar Persona. \n[2]Mostrar Personas. \n[3]Salir" << endl;
        opc = leerentero("\nIngrese su opcion: ");
 
        switch(opc)
        {
            case 1:
                cout << b.agregar(leercliente()) << endl;
            break;
            case 2: cout << b.mostrar() << endl;
            break;
            case 3: return 0;
            break;
 
        }
 
    }while(opc!=3);
 
    return 0;
}