C++ Threads(Hilos)

C++ Thread

Ejemplo de como implementar threads con la libreria thread en c++

El programa debe calcular el area de circulos y triangulos por separado.

/* Version g++ 4.6.3 - Linux/Ubuntu 12.04
 * Compilacion g++ qareas.cpp -o qarea -std=c++0x -pthread
 */
#include <iostream> 
#include <stdlib.h>
#include <thread>
#define CIRCLES 10
#define TRIANGLES 10
using namespace std;

class Circle
{
  public:
    Circle(int r) : radio(r) {}
    ~Circle() {}

    void circleArea(){ area = 3.14159 * (radio*radio); }
    void showArea(){ cout<<"C -"<<radio<<" - "<<area<<endl; }

  private:
    int radio;
    double area;
};

class Triangle
{
  public:
    Triangle(int b, int h) : base(b), high(h) {}
    ~Triangle(){  }

    void triangleArea(){ area = ( base * high) / 2; }
    void showArea(){ cout<<"T -"<<base<<" - "<<high<<" - "<<area; }
  private:
    int base, high;
    double area;
};

void TrianglesArea(){
  int i;
  srand (time(NULL));
  for(i = 0; i < TRIANGLES; i++){
    Triangle* t = new Triangle(rand()%10+1,rand()%15+10);
    t->triangleArea();
    t->showArea();
    delete t;
    sleep(1);
  }
}

void CirclesArea(){
  int i;
  srand (time(NULL));
  for(i = 0; i < CIRCLES; i++){
    Circle* c = new Circle(rand()%10+1);
    c->circleArea();
    c->showArea();
    delete c;
    sleep(1);
  }
}
int main(void){

  cout<<"Id Area"<<endl;
  thread circles(CirclesArea);
  thread triangles(TrianglesArea);

  circles.join();
  triangles.join();

  return 0;
}

Ruby Threads(Hilos) script

Threads Ruby

Simple script en ruby, que muestra el manejo de threads(hilos)

El programa debe calcular el area de circulos y triangulos por separado.

Mayor informacion Ruby Multithreading

class Triangle
  attr_accessor :attributes

  def initialize
    @attributes = {
      base:   Random.rand(1..10),
      high: Random.rand(10..15)
    }
  end

end

class Circle
  attr_accessor :attributes

  def initialize
    @attributes = {
      radio: Random.rand(1..10)
    }
  end
end

class QAreas

  @triangles = []
  @circles = []

  def self.generate_triangles
    10.times do |id|
      t = Triangle.new
      @triangles << [id, t.attributes[:base], t.attributes[:high] ]
    end
  end

  def self.triangle_area(b,h)
    return (b * h ) / 2
  end

  def self.generate_circles
    10.times do |id|
      c = Circle.new
      @circles << [id,c.attributes[:radio]]
    end
  end

  def self.circle_area r
    return Math::PI * (r*r)
  end

  def self.start
    QAreas::generate_triangles
    QAreas::generate_circles
    print 'Type-id Area'
    puts ''

    th_triangle = Thread.new do 
      @triangles.each do |id, base, high|
        area = QAreas::triangle_area(base,high)
        print 'T -', id, ' - ', base, '-', high,  '-',area
        puts ''
        sleep(0.2)
      end
    end

    th_cirlce = Thread.new do
      @circles.each do |id, r|
        area =  QAreas::circle_area r
        print 'C -', id, ' - ', r
        puts ''
        sleep(0.2)
      end
    end

    th_triangle.join
    th_cirlce.join
  end

end

QAreas.start

C++ Parser Operaciones Algebraicas Lineales archivo.txt

Un analizador sintáctico (en inglés parser) es una de las partes de un compilador que transforma su entrada en un árbol de derivación. El análisis sintáctico convierte el texto de entrada en otras estructuras (comúnmente árboles), que son más útiles para el posterior análisis y capturan la jerarquía implícita de la entrada. Un analizador léxico crea tokens de una secuencia de caracteres de entrada y son estos tokens los que son procesados por el analizador sintáctico para construir la estructura de datos, por ejemplo un árbol de análisis o árboles de sintaxis abstracta.

Source https://github.com/torukMnk/Q-parser

Archivo .txt

lado1=5;
lado2=86;
base=105;
color2=200;
calculo=lado1+lado2-base+300-100/color2-4;

Salida :: Q-Compiler ::

lado1=5;
lado2=86;
base=105;
color2=200;
calculo=-3.07;

q-compiler.cpp

/**
 * 
 * Desarrollador: Guillermo Quezada de Pedro
 * Sem: 6 Grupo "F"
 * Profesor: M.C. Benjamin Iglesias Cortes
 * 
 * */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <sstream>
#include <iostream>
#define MEM_LINES 128
#define MEM_VARIABLES 128
#define MEM_OPERATIONS 128

using namespace std;

class Compilation
{
  FILE *_file;
  long lSize;
  char *buffer;
  int char_count;
  size_t result;
  char *q_buffer;
  int q_count;
  int _line;
  int n_digit;

  struct lines
  {
    char line_data[MEM_VARIABLES];
    int len;
  }line[MEM_LINES];

  struct asignations
  {
    char variable[MEM_VARIABLES];
    float value;
    int len;
    int n_operators;
  }asignation[MEM_LINES];

  struct operations
  {
    char variable[MEM_VARIABLES];
    char _operator;
    float value;
    int line;
  }operation[MEM_OPERATIONS];

  public:

  void file_read(char file_name[])
  {
    _file = fopen(file_name,"rb");
    if (_file==NULL) {fputs ("File error",stderr); exit (1);}
    fseek(_file,0,SEEK_END);
    lSize = ftell(_file);
    rewind(_file);
    buffer = (char*)malloc(sizeof(char)*lSize);
    result = fread(buffer,1,lSize,_file);
    fclose (_file);
  }

  void file_compress()
  {
    q_count = 0;
    q_buffer = (char*)malloc(sizeof(char)*lSize);
    for(char_count = 0;char_count < lSize;char_count++)
    {
      if(buffer[char_count] != ' ' )
      {
        q_buffer[q_count] = buffer[char_count];
        q_count +=1;
      }
    }
    free(buffer);
  }

  void compile_lines()
  {
    memset( &line, 0, sizeof(line) );
    int _char;
    int _data;
    _line = 0;
    _data = 0;

    for(_char = 0; _char < q_count; _char++)
    {
      line[_line].line_data[_data] = q_buffer[_char];
      _data +=1;
      if( q_buffer[_char] == ';' )
      {
        line[_line].len = strlen(line[_line].line_data);
        _line +=1;
        _data = 0;
      }
    }
    free(q_buffer);
  }

  void compile_variables_assignation()
  {
    memset( &asignation, 0, sizeof(asignation) );
    int _char;
    int i;
    _char = 0;
    for(i=0;i < _line;i++)
    {
      while(line[i].line_data[_char] != '=')
      {
        asignation[i].variable[_char] = line[i].line_data[_char];
        _char +=1;
      };
      asignation[i].len = strlen(asignation[i].variable);
      _char = 0;
    }
  }

  void compile_variables_operation()
  {
    memset( &operation, 0, sizeof(operation) );
    int i;                  //Numero de Linea
    int len;                //Longitud de linea
    int k;                  //Lector de caracteres en la linea
    int _digit;             //Posicion de nuevo valor en la linea digit
    int _char;
    int count_as;           //Variables asignacion indirectas

    len = 0;
    n_digit = 0;
    _digit = 0;
    count_as = 0;

    for(i=0;i < _line; i++)
    {
      _char = asignation[i].len+1;
      len = line[i].len;

      for(k=0; k < len; k++)
      {
        if (isdigit(line[i].line_data[_char]))
        {
          operation[n_digit].variable[_digit] = line[i].line_data[_char];
          operation[n_digit].line = i;
          _digit +=1;
          _char+=1;
        }
        else if(isalpha(line[i].line_data[_char]))
        {
          operation[n_digit].variable[_digit] = line[i].line_data[_char];
          operation[n_digit].line = i;
          _digit +=1;
          _char+=1;
        }

        else
        {
          if(line[i].line_data[_char] != ';')
          {
            operation[n_digit+1]._operator = line[i].line_data[_char];
          }
          n_digit +=1;
          _digit = 0;
          _char +=1;
        }
        if(_char == len) k = len;
      }
    }

    //ASCII TO INTEGER
    for(i = 0; i < n_digit; i++)
    {
      operation[i].value = atoi(operation[i].variable);
    }

    //Operaciones Algebraicas Basicas(Lineal)
    float total;
    int n_operator;
    total = 0;
    n_operator = 0;
    for(i = 0; i < _line+1; i++)
    {
      for(k = 0; k < n_digit; k++)
      {
        if(operation[k].line == i)
        {
          if(isalpha(operation[k].variable[0]))
          {
            if(strcmp(operation[k].variable,asignation[k].variable))
            {
              operation[k].value = asignation[count_as].value;
              count_as += 1;
            }
          }

          n_operator +=1;
          asignation[i].n_operators = n_operator;
          if(operation[k]._operator == '\0')
          {
            total += operation[k].value;
            asignation[i].value = total;
          }
          if(operation[k]._operator == '+')
          {

            total += operation[k].value;
            asignation[i].value = total;
          }
          if(operation[k]._operator == '-')
          {
            total -= operation[k].value;
            asignation[i].value = total;
          }
          if(operation[k]._operator == '*')
          {
            total *= operation[k].value;
            asignation[i].value = total;
          }
          if(operation[k]._operator == '/')
          {
            total /= operation[k].value;
            asignation[i].value = total;
          }

        }
        else
        {
          total = 0;
          n_operator = 0;
        }
      }
    }
  }
  void q_file_make(char file_name[])
  {
    //Errores de visualizacion de SyntaxHighlighter
    //Funcion completa ->
    //https://github.com/torukMnk/Q-parser
  }

};

int main(void)
{
  Compilation com;
  char option;
  char name[16];

  do{
    //system("cls");   //Windows
    system("clear");   //Linux
    cout<<":: Q Compiler ::"<<"\n";
    cout<<"Nombre del archivo: ";
    cin>>name;
    cout<<'\n';
    com.file_read(name);
    com.file_compress();
    com.compile_lines();
    com.compile_variables_assignation();
    com.compile_variables_operation();
    com.q_file_make(name);

    cout<<"Desea compilar otro archivo: (Y/N): ";
    cin>>option;
    option = toupper(option);

  }while(option != 'N');
}

C++ Manejo de Cadenas

Manejo de Cadenas
Separacion Consonantes y Vocales
Separacion de Cadenas

#include 

using namespace std;

struct data{
    char cadenas[64];
}words[32];

void divition();
int main(void){

    char _string[64];
    cout<<"Escribe palabras maximo 32: ";
    cin.getline(_string,64);
    divition();

    /*
    *  Separar - Consonantes y Vocales
    */
    
    int cont;
    int len;

    char vocales[64];
    char consonantes[64];

    int count_v = 0;
    int count_c = 0;

    len = strlen(_string);
    _string[len] = ' ';

    for(cont= 0;cont < len; cont++)
    {
        if(_string[cont] == 'a' || _string[cont] == 'e' ||
           _string[cont] == 'i' || _string[cont] == 'o' || 
           _string[cont] == 'u')
        {
            vocales[count_v] = _string[cont];
            count_v +=1;
        }
        else
        {
            if(_string[cont] != ' ')
            {
                consonantes[count_c] = _string[cont];
                count_c += 1;
            }
        }
    }

    /*
    * Separar - Cadenas
    */

    int n_string = 0;
    int n_len = 0;
    for(cont = 0;cont <= len;cont++)
    {
        words[n_string].cadenas[n_len] = _string[cont];
        n_len +=1;
        if(_string[cont] == ' ')
        {
            n_string +=1;
            n_len = 0;
        }
    }
    
    /*
     * Separar -Mayusculas - Minusculas
     */

    char mixed[64];
    int val;
    
    for(cont = 0;cont < len; cont++)
    {
        val = cont%2;
        if(val == 0){ mixed[cont] = toupper(_string[cont]); }
        else{ mixed[cont] = tolower(_string[cont]); }
    }
    
 /*******************************************************/
    //Mostrar Cadenas
    for(cont = 0; cont < n_string; cont++){
        cout<<"Cadena["<<cont<<"]: "<<words[cont].cadenas<<endl;
    }
    divition();
    
    //Mostrar Vocales
    cout<<"Vocales: "<<endl;
    for(cont = 0; cont < count_v; cont++){ cout<<vocales[cont]; }
    cout<<endl;
    cout<<"Numero de Vocales: "<<count_v<<endl;
    divition();

    //Mostrar Consonantes
    cout<<"Consonantes"<<endl;
    for(cont = 0; cont < count_c; cont++){ cout<<consonantes[cont]; }
    cout<<endl;
    cout<<"Numero de consonantes: "<<count_c<<endl;
    divition();

    //Mostrar Mayusculas y Minusculas
    cout<<"Mayusculas - Minusculas"<<endl;
    for(cont = 0;cont < len; cont++){ cout<<mixed[cont]; }

    return 0;
}

void divition(){
    cout<<"============================================"<<endl;
}