CONDUCTORES ELECTRICOS
Son materiales no metálicos que también poseen la propiedad de conducir la electricidad, como el grafito o las disoluciones y soluciones salinas (por ejemplo, el agua de mar) o cualquier material en estado de plasma.
Para el transporte de energía eléctrica, así como para cualquier instalación de uso doméstico o industrial, el mejor conductor es el cobre (en forma de cables de uno o varios hilos). Aunque la plata es el mejor conductor, pero debido a su precio elevado no se usa con tanta frecuencia. También se puede usar el aluminio, metal que si bien tiene una conductividad eléctrica del orden del 60% de la del cobre, es sin embargo un material tres veces más ligero, por lo que su empleo está más indicado en líneas aéreas que en la transmisión de energía eléctrica en las redes de alta tensión. A diferencia de lo que mucha gente cree, el oro es levemente peor conductor que el cobre; sin embargo, se utiliza en bornes de baterías y conectores eléctricos debido a su durabilidad y “resistencia” a la corrosión.
La conductividad eléctrica del cobre puro fue adoptada por la Comisión Electro técnica Internacional en 1913 como la referencia estándar para esta magnitud, estableciendo el International Annealed Copper Standard (Estándar Internacional del Cobre Recocido) o IACS. Según esta definición, la conductividad del cobre recocido medida a 20 °C es igual a 58.0 MS/m. A este valor es a lo que se llama 100% IACS y la conductividad del resto de los materiales se expresa como un on materiales cuya resistencia al paso de la electricidad es muy baja. Los mejores conductores eléctricos son metales, como el cobre, el oro, el hierro y el aluminio, y sus aleaciones, aunque existen otros cierto porcentaje de IACS. La mayoría de los metales tienen valores de conductividad inferiores a 100% IACS pero existen excepciones como la plata o los cobres especiales de muy alta conductividad designados C-103 y C-110.
ELECTROLISIS
Es el proceso que separa los elementos de un compuesto por medio de la electricidad. En ella ocurre la captura de electrones por los cationes en el cátodo (una reducción) y la liberación de electrones por los aniones en el ánodo (una oxidación).
Fue descubierta accidentalmente en 1800 por William Nicholson mientras estudiaba el funcionamiento de las baterías. Entre los años 1833 y 1836 el físico y químico inglés Michael Faraday desarrolló las leyes de la electrólisis que llevan su nombre y acuñó los términos.
ELECTRO LITO
Un electro lito o electrólito es cualquier sustancia que contiene iones libres, los que se comportan como un medio conductor eléctrico. Debido a que generalmente consisten en iones en solución, los electrolitos también son conocidos como soluciones iónicas, pero también son posibles electrolitos fundidos y electro litossólidos.
ELECTRODO
Un electrodo es un conductor eléctrico utilizado para hacer contacto con una parteno metálica de un circuito, por ejemplo un semiconductor, un electrolito, el vacío(en una válvula termoiónica), un gas (en una lámpara de neón), etc. La palabra fue acuñada por el científico Michael Faraday y procede de las voces griegas elektron, que significa ámbar y de la que proviene la palabra electricidad; y hodos, que significa camino.
CORRIENTE ELÉCTRICA
Lo que conocemos como corriente eléctrica no es otra cosa que la circulación de cargas o electrones a través de un circuito eléctrico cerrado, que se mueven siempre del polo negativo al polo positivo de la fuente de suministro de fuerza electromotriz (FEM).
Las teconologías disponibles para la rectificación están basadas en el empleo de diodos (caso de la figura) o tiristores. En este último caso, la potencia de salida es regulable por lo que se emplean en numerosas aplicaciones industriales, por ejemplo, hornos en los que es necesario regular la temperatura en función del uso, lo que no puede hacerse empleando simples diodos.
Definiendo una función[editar]
Una función es un conjunto de líneas de código que realizan una tarea específica y puede retornar un valor. Las funciones pueden tomar parámetros que modifiquen su funcionamiento. Las funciones son utilizadas para descomponer grandes problemas en tareas simples y para implementar operaciones que son comúnmente utilizadas durante un programa y de esta manera reducir la cantidad de código. Cuando una función es invocada se le pasa el control a la misma, una vez que esta finalizó con su tarea el control es devuelto al punto desde el cual la función fue llamada.
<tipo> [clase::] <nombre> ( [Parámetros] )
{
cuerpo;
}
Ejemplo de una función
Para comenzar, vamos a considerar el caso en el cual se desea crear la función cuadrado(), que deberá devolver el cuadrado de un número real (de punto flotante), es decir, cuadrado() aceptará números de punto flotante y regresará una respuesta como número flotante.
Nota: aunque para la función que veremos el tipo de retorno coincide con el tipo de parámetro pasado, algunas veces las cosas pueden cambiar, es decir, no es obligatorio que una función reciba un parámetro de un tipo y que tenga que regresar una respuesta de dicho tipo.
// regresar el cuadrado de un número
double Cuadrado(double n)
{
return n*n;
}
Parámetros[editar]
Normalmente, las funciones operan sobre ciertos valores pasados a las mismas ya sea como constantes literales o como variables, aunque se pueden definir funciones que no reciban parámetros. Existen dos formas en C++ de pasar parámetros a una función; por referencia o por valor. El hecho es que si en una declaración de función se declaran parámetros por referencia, a los mismos no se les podrá pasar valores literales ya que las referencias apuntan a objetos (variables o funciones) residentes en la memoria; por otro lado, si un parámetro es declarado para ser pasado por valor, el mismo puede pasarse como una constante literal o como una variable. Los parámetros pasados por referencia pueden ser alterados por la función que los reciba, mientras que los parámetros pasados por valor o copia no pueden ser alterados por la función que los recibe, es decir, la función puede manipular a su antojo al parámetro, pero ningún cambio hecho sobre este se reflejará en el parámetro original.
Parámetros por valor
La función cuadrado() (ver arriba) es un clásico ejemplo que muestra el paso de parámetros por valor, en ese sentido la función cuadrado() recibe una copia del parámetro n. En la misma función se puede observar que se realiza un calculo ( n*n ), sin embargo el parámetro original no sufrirá cambio alguno, esto seguirá siendo cierto aún cuando dentro de la función hubiera una instrucción parecida a n = n * n; o n*=n;.
Parámetros por referencia
Para mostrar un ejemplo del paso de parámetros por referencia, vamos a retomar el caso de la función cuadrado, salvo que en esta ocasión cambiaremos ligeramente la sintaxis para definir la misma. Veamos:
// regresar el cuadrado de un número
double cuadrado2(double &n)
{
n *= n;
return n;
}
Al poner a prueba las funciones cuadrado() y cuadrado2() se podrá verificar que la primera de estas no cambia el valor del parámetro original, mientras que la segunda sí lo hace.
Llamar a una función[editar]
para llamar a la función cuadrado() vista anteriormente, podemos emplear:
cout << cuadrado(25);
cout << cuadrado(X);
R = cuadrado(X); // guardar en R el cuadrado de X
Funciones void[editar]
Bajo ciertas circunstancias se deseará escribir funciones que no regresen valor alguno (esto sería algo parecido a escribir procedures en Pascal) y para ello podemos declarar a la función como void. La palabra reservada void es utilizada para declarar funciones sin valor de retorno y también para indicar que una función específica no requiere de parámetros. Por ejemplo, la función pausa() que se verá en seguida, no devolverá valor alguno y la misma no requiere de parámetros.
// esta función requiere de la librería iostream
void pausa(void)
{
cout << "Por favor presione <Enter> HOLA...";
cin.get();
cin.ignore(255, '\n'); // rechazar caracteres introducidos antes de <Enter>
}
Notas: se debe de aclarar que el uso de la palabra void dentro de los parentesis es opcional al momento de declarar una función. Así, la función pausa() podría haberse declarado como void pausa(), y la misma puede invocarse como: pausa();.
Funciones anidadas[editar]
A diferencia de Pascal, el lenguaje C, C++ no permite anidar funciones, sin embargo, dentro de una funcíon puede existir la llamada a una o más funciones declaradas previamente, que determinara en cierto punto un resultado para que sea ejecutado cuando el programador lo desee.
Funciones de tipo puntero (*)[editar]
En muchas ocasiones se desea que ciertas funciones regresen una referencia o puntero hacia un tipo (sea este estructurado o no) específico de dato en lugar de un valor específico. En tales casos, la función se deberá declarar como para que regrese un puntero. Por ejemplo, supongamos que deseamos crear una función para convertir un número entero en notación decimal a una cadena de caracteres en forma de números binarios, luego, la función mencionada podría escribirse para que reciba el número entero como parámetro y regrese un puntero a una cadena de caracteres conteniendo la conversión. Para ser más puntuales, vamos a escribir un programa en donde se verá la función binstr(), y cuyo objetivo será precisamente convertir números decimales en cadenas binarias.
Nota: observe que en la sintaxis para declarar funciones tipo puntero se debe de poner el símbolo *despues del tipo y antes del nombre de la función que se está declarando. Esto se puede ver en el programa, ya que la función binstr se declara como: char *binstr(unsigned int);
#include <iostream>
#include <string.h>
using namespace std;
// declaración de prototipo
char *binstr(unsigned int);
// punto de prueba
int main()
{
int n = 128;
cout << "decimal = " << n << ", binario = " << binstr(n) << endl;
cin.get();
}
// definición de función binstr()
// nota: esta funcion requiere de la librería estándar string
char *binstr(unsigned int n)
{
static char buffer[65];
int i = 0;
strcpy(buffer, "0");
if (n > 0) {
while (n > 0) {
buffer[i] = ( n & 1 ) + '0';
i++;
n >>= 1;
}
buffer[i] = '\0';
strrev(buffer);
} // fin (n > 0)
return buffer;
}
Variables estáticas y automáticas[editar]
Dentro de una función, las variables y/o constantes pueden ser declaradas como: auto (por omisión) o comostatic. Si una variable dentro de una función es declarada como estática significa que la misma retendrá su valor entre las llamadas a la función. Por otro lado, la variables automáticas pierden su valor entre las llamadas. En el programa anterior puede verse que el arreglo de caracteres (buffer[65]) se ha declarado como estático para garantizar que dicho buffer retenga los datos aún despues de que la función termine. En el mismo ejemplo, si el buffer no se declara como estático, el contenido del mismo podría ser destruido al salir de la función y los resultados obtenidos podrían ser no deseados.
Parámetros constantes[editar]
Los parámetros usados por una función pueden declararse como constantes ( const ) al momento de la declaración de la función. Un parámetro que ha sido declarado como constante significa que la función no podrá cambiar el valor del mismo ( sin importar si dicho parámetro se recibe por valor o por referencia ).
Ejemplo:
int funcionX( const int n ); void printstr( const char *str ); Parámetros con valor por defecto[editar]
Los parámetros usados por una función pueden declararse con un valor por defecto. Un parámetro que ha sido declarado con valor por defecto es opcional a la hora de hacer la llamada a la función. Ejemplo: Dada la función:
void saludo( char* mensaje = "Hola Copa America 2015" );
la misma puede ser invocada como:
saludo(); // sin parámetro
saludo("Sea usted bienvenido a C++"); // con parámetro
Para ver un ejemplo más, vamos a considerar el caso de la función binstr() del programa funciones01. Ahora, vamos modificar dicha función, salvo que esta ocasión nos interesa que la misma sirva para convertir números decimales en cadenas numéricas y cuya base de conversión sea pasada como parámetro. Es decir, la función de la que estamos hablando podrá convertir números decimales a: binario, octal, decimal, hexadecimal, etc.; y la única condición será que la base indicada esté entre el 2 y el 36, inclusive.
Nota: Ya que la función servirá para convertir números a cualquier representación la nombraremos comonumstr() en lugar de binstr(). Si la función es invocada sin el parámetro base regresará una cadena de digitos decimales.
#include <iostream>
#include <stdlib.h>
using namespace std;
// declaración de prototipo
char *numstr(unsigned int, const int base = 10);
// punto de prueba
int main()
{
int n = 128;
cout << "decimal = " << n << ", binario = " << numstr(n, 2) << endl;
cout << "decimal = " << n << ", octal.. = " << numstr(n, 8) << endl;
cin.get();
}
// definición de función numstr()
// nota: esta funcion requiere de la librería stdlib.h
char *numstr(unsigned int n, const int base)
{
static char buffer[65];
itoa(n, buffer, base);
return buffer;
}
Parámetros de tipo puntero[editar]
Anteriormente se mencionó que en C++ los parámetros a una función pueden pasarse por valor o por referencia, al respecto, podemos agregar que los parámetros también pueden pasarse como punteros. El paso de parámetros de punteros es bastante parecido al paso de parámetros por referencia, salvo que el proceso de los datos dentro de la función es diferente. Por ejemplo, las funciones:
void referencia( int &X ) { X = 100; }
void puntero( int *X ) { *X = 100; }
Parámetros estructurados[editar]
Al igual que cualquier otro tipo los parámetros de tipo estruturado pueden pasarse por valor o por referencia, sin embargo, podría ser que si una estructura es pasada por valor el compilador mostrara una advertencia ( warning ) indicando que se pasado por valor una estructura, puesto que el paso de estructuras por valor es permitido usted puede ignorar la advertencia, pero lo mejor es pasar estructuras por referencia. Si una estructura es pasada por valor y si esta es muy grande podria ser que se agotara la memoria en el segmento de pila ( Stack Segment ), aparte de que la llamada a la función sería más lenta.
Para ver un ejemplo, consideremos el caso del siguiente tipo estructurado:
struct empleado {
char nombre[32];
int edad;
char sexo;
};
Ahora, pensemos que deseamos escribir una función para imprimir variables del tipo empleado. Así, la función puede escribirse de las tres maneras siguientes:
void ImprimeEmpleadoV( empleado e)
{
cout << "Nombre: " << e.nombre << endl;
cout << "Edad: " << e.edad << endl;
cout << "Sexo: " << e.sexo << endl;
}
// Parametro empleado pasado por referencia
void ImprimeEmpleadoR( empleado &e )
{
cout << "Nombre: " << e.nombre << endl;
cout << "Edad: " << e.edad << endl;
cout << "Sexo: " << e.sexo << endl;
}
// Parametro empleado pasado como puntero
void ImprimeEmpleadoP( empleado *e )
{
cout << "Nombre: " << e->nombre << endl;
cout << "Edad: " << e->edad << endl;
cout << "Sexo: " << e->sexo << endl;
}
Funciones sobrecargadas[editar]
C++, a diferencia del C estándar, permite declarar funciones con el mismo nombre y a esto se conoce comosobrecarga de funciones. Las funciones sobrecargadas pueden coincidir en tipo, pero al menos uno de sus parámetros tiene que ser diferente. En todo caso, si usted trata de declarar funciones sobrecargadas que coincidan en tipo y número de parámetros el compilador no se lo permitirá. Para poner un ejemplo vamos a considerar el caso de dos funciones cuyo nombre será divide, ambas regresarán el cociente de dos números, salvo que una de ellas operará sobre números enteros y la otra lo hará sobre números reales ( de punto flotante ).
Nota: cuando en los programas se hace una llamada a una función sobrecargada, el compilador determina a cual de las funciones invocar en base al tipo y número de parámetros pasados a la función.
#include <iostream.h>
#include <stdlib.h>
using namespace std;
// divide enteros
int divide(int a, int b)
{
cout << "división entera" << endl;
return ( (b != 0) ? a/b : 0);
}
// divide reales
double divide(double a, double b)
{
cout << "división real" << endl;
return ( (b != 0) ? a/b : 0);
}
// punto de prueba
int main()
{
cout << divide(10, 3) << endl;
cout << divide(10.0, 3.0) << endl;
cin.get();
}
Número variable de parámetros[editar]
En C,C++ se pueden crear funciones que operen sobre una lista variable de parámetros, es decir, en donde el número de parámetros es indeterminado. En esta sección se mostrará un ejemplo de la manera en que podemos crear funciones para manejar tales asuntos, y para ello haremos uso de tres macros soportadas por C++:
La sintaxis que usaremos para declarar funciones con lista de parámetros variables es:
1) tipo nombrefuncion(...) 2) tipo nombrefuncion(int num, ...)
donde:
Nota: observe que la primera forma de declaración es realmente variable el número de parámetros a procesar y en estos casos se debe establecer el mecanismo para determinar cuando se ha procesado el último de los argumentos, en el segundo tipo de declaración el número total de parámetros a procesar es igual al valor del parámetro num.
En el siguiente programa, por ejemplo, se define una función ( printstr ) que despliega una lista variable de cadenas de caracteres.
#include <iostream.h>
#include <stdarg.h>
// despliega una lista de cadenas, la ultima debe ser NULL
void printstr(...)
{
va_list ap;
char *arg;
va_start(ap, 0);
while ( (arg = va_arg(ap, char*) ) != NULL) {
cout << arg;
}
va_end(ap);
}
int main()
{
printstr("Hola, ", "Esta es\n", "una prueba\n", NULL);
cin.get();
return 0;
}
En el programa que se listará en seguida, se define la función suma(), misma que operará sobre listas de números enteros, la función devolverá la suma de dichos números.
#include <iostream>//entrada y salida
#include <stdarg.h>
using namespace std;
// Esta función opera sobre una lista variable de números enteros
int suma( int num, ... )
{
int total = 0;
va_list argptr;
va_start( argptr, num );
while( num > 0 ) {
total += va_arg( argptr, int );
num--;
}
va_end( argptr );
return( total );
}
int main()
{
cout << suma(4, 100, 200, 300, 400) << endl;
cin.get();
return 0;
}
DIAGRAMA DE FLUJO
| ||||||||||||||||
Aplique funciones al cálculo de conductores
ResponderEliminar