Paso de arreglos y punteros como parámetros.
Paso de Arreglos como
Parametros
Para pasar arreglos como parámetros
debemos recordar que con arreglos no existe el paso por valor como existía en
las variables individuales, solo se puede pasar por referencia(dirección)lo que
quiere decir que todas las modificaciones que se hagan dentro del arreglo
afectaran también a la variable original
Para pasar un arreglo
completo como parametro a un procedimiento a una función solo se manda el
nombre del arreglo sin corchetes e indices, en el procedimiento o función que
recibe solo se declara un arreglo del mismo tipo y se puede usar el mismo o
diferente nombre del arreglo.
Entonces tenemos 2
maneras:
void func(int a[]);
void func(int a[5]);
void func(int a[5]);
Ejemplo:
int ingreso(int );
void imprimir(int );
void main() {
int n[100];
ingreso(n[100]);
imprimir(n[100]);
system("pause");
}
int ingreso(int vect) {
for (int i = 0; i < 5; i++) {
cout << "Ingrese un numero: ";
cin >> vect;
return vect;
}
}
void imprimir(int vect) {
for (int i = 0; i < 5; i++) {
cout << ingreso(vect) << "\n";
(vect++);
}
}
Paso de arreglos
utilizando punteros
La manera de declarar la función
es:
void func(int *a);
Podemos acceder a los
elementos de un modo alternativo usando un puntero de esta manera:
int *ptr;
ptr = &mi_arreglo[0]; /* apuntamos nuestro
apuntador al primer entero de nuestro arreglo */
ejemplo:
int mi_arreglo[] =
{1,23,17,4,-5,100};
int *ptr;
int main(void)
{
int i;
ptr = &mi_arreglo[0]; /* apuntamos nuestro
puntero
al primer elemento del arreglo*/
printf("\n\n");
for (i = 0; i < 6; i++)
{
printf("mi_arreglo[%d] = %d ", i,
mi_arreglo[i]); /*<-- A */
printf("ptr + %d = %d\n",i, *(ptr +
i)); /*<-- B */
}
return 0;
}
En C, el estándar
establece que donde usemos &nombre_de_la_variable[0] podemos reemplazarle
con nombre_de_la_variable, esto en el código de ejemplo lo que escribimos como:
ptr = &mi_arreglo[0];
podemos escribirlo como:
ptr = mi_arreglo;
y obtenemos el mismo
resultado.
Arreglos en Memoria Dinámica
Para utilizar un arreglo en memoria dinámica debemos declarar: arreglo =
new char[filas]; de esta manera podemos reservar memoria para cada uno de sus
espacios.
char * cadena_dinamica = NULL; // arreglo vacio.
int cantidad = 0;
//obtenemos un valor de cantidad
capturado de consola
cout<< "Por favor
digite el tamaño del arreglo ";
cin>>cantidad;
// creamos el arreglo dinámico
con el parametro capturado
cadena_dinamica = new
char[cantidad];
Paso de Matrices como
Parametros
Para matrices, funciona
de la misma forma que existía para arreglos, al momento de declarar la función es
importante especificar el numero de columnas ya que la función receptora
debe conoce la estructura interna de la matriz, para poder para acceder a sus
elementos, y esto solo es posible informándole de su tipo y dimensiones.
int matriz[100][100];
void main() {
int n, n1;
cout << "ingrese el tamaño de la fila = ";
cin >> n;
cout << "ingrese el tamaño de la columna = ";
cin >> n1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; n++) {
cout << "ingrese el valor de ["
<< i+1 << "],[" << j+1 << "] =";
cin >> matriz[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n1; n++) {
//gotoxy(i + 5, 2 * j + 3);
cout << matriz[i][j];
}
}
}
func (int dias[2][12]) {...}
Matrices en memoria dinámica
Para utilizar matrices
con memoria dinámica primero debemos reservar el espacio para el numero de
filas como si fuera un vector mat = new int*[*dim]; después lo hacemos para
cada una de sus columnas, para la lectura de datos utilizamos la estructura
siguiente: (&(*(*(mat + i) + j))) o también (*(*(&mat) + i) + j)), y
para la escritura (*(*(mat + i) + j))
void diagonal();
void ingreso(int **, int
*);
void ingresomat(int **,
int *);
void impresion(int **,
int *);
int main() {
diagonal();
system("pause");
}
void diagonal() {
int **mat, *dim;
ingreso(mat, dim);
system("pause");
}
void ingreso(int **mat,
int *dim) {
dim = new (int);
cout << "ingrese dimension" << endl;
scanf("%d", (&(*dim)));
mat = new int*[*dim];
for (int i = 0; i < *dim; i++) {
*(mat+i) = new int[*dim];
}
ingresomat(mat, dim);
}
void ingresomat(int
**mat, int *dim) {
for (int i = 0; i < *dim; i++) {
for (int j = 0; j < *dim; j++) {
scanf("%d", (&(*(*(mat + i) + j))));
}
}
impresion(mat, dim);
}
void impresion(int **mat,
int *dim) {
for (int i = 0; i < *dim; i++) {
for (int j = 0; j < *dim; j++) {
printf("%d", *(&(*(*(mat + i) +
j))));
}
cout << endl;
}
}
Programa que Multiplica 2
matrices en memoria dinamica
void multiplicacion();
void datosmat(int **,int
*,int *);
void impresion(int
**mat,int *fila, int *columna);
void encerar(int
**mat,int *filas, int *columnas);
void multiplicar(int
**mat1,int **mat2,int **mat3,int *filas,int *filas2, int *columnas2);
int main(){
multiplicacion();
return 0;
}
void multiplicacion(){
int *filas=new (int),*columnas=new (int);
cout<<"ingrese las dimensiones de la matriz
1"<<endl;
cin>>*filas>>*columnas;
int **mat1=new int*[*filas];
for(int i=0;i<*filas;i++){
*(mat1+i)=new int[*columnas];
}
int *filas2=new (int),*columnas2=new (int);
cout<<"ingrese las dimensiones de la matriz
1"<<endl;
cin>>*filas2>>*columnas2;
int **mat2=new int*[*filas2];
for(int i=0;i<*filas2;i++){
*(mat2+i)=new int[*columnas2];
}
cout<<"ingrese datos de matriz 1"<<endl;
datosmat(mat1,filas,columnas);
cout<<"datos de la matriz 1:"<<endl;
impresion(mat1,filas,columnas);
cout<<"ingrese datos de la matriz
2"<<endl;
datosmat(mat2,filas2,columnas2);
cout<<"datos de la matriz 2:"<<endl;
impresion(mat2,filas2,columnas2);
int **mat3=new int*[*filas];
for(int i=0;i<*filas;i++){
*(mat3+i)=new int[*columnas2];
}
cout<<"datos de la matriz 3"<<endl;
encerar(mat3,filas,columnas2);
cout<<endl<<endl;
cout<<"la multiplicacion es:"<<endl;
multiplicar(mat1,mat2,mat3,filas,filas2,columnas2);
}
void datosmat(int
**mat,int *filas, int *columnas){
for(int i=0;i<*filas;i++){
for(int j=0;j<*columnas;j++){
//scanf("%d",&(*(*(mat+i)+j)));
scanf("%d",*(*(&mat)+i)+j);
// cin>>mat[i][j];
}
}
}
void impresion(int
**mat,int *filas, int *columnas){
for(int i=0;i<*filas;i++){
for(int j=0;j<*columnas;j++){
printf("%d ",*(*(mat+i)+j));
//printf("%d ",*(*(mat)+i)+j);
}
cout<<endl;
}
}
void encerar(int
**mat,int *filas, int *columnas){
for(int i=0;i<*filas;i++){
for(int j=0;j<*columnas;j++){
*(*(mat+i)+j)=0;
// printf("%d",*(*(mat+i)+j));
}
cout<<endl;
}
}
void multiplicar(int
**mat1,int **mat2,int **mat3,int *filas,int *filas2, int *columnas2){
for (int k = 0; k<*filas; k++) {
for (int f = 0; f<*columnas2; f++) {
for (int c = 0; c<*filas2; c++) {
*(*(mat3+k)+f )= *(*(mat3+k)+f )
+ (*(*(mat1+k)+f ) * (*(*(mat2+k)+f )));
}
printf("%d ",*(*(mat3+k)+f));
}
cout << endl;
}
}
Arreglos de punteros
Son vectores cuyos
elementos son punteros, cada uno de estos puede apuntar a un tipo de dato
especifico
Funciones Recursivas
FUNCIONES RECURSIVAS
Se dice que una función es recursiva cuando se define en función de si misma.
No todas las funciones pueden llamarse a sí mismas, sino que deben estar diseñadas especialmente para que sean recursivas, de otro modo podrían conducir a bucles infinitos, o a que el programa termine inadecuadamente.
Tampoco todos los lenguajes de programación permiten usar recursividad.
C++ permite la recursividad. Cada vez que se llama a una función, se crea un juego de variables locales, de este modo, si la función hace una llamada a sí misma, se guardan sus variables y parámetros, usando la pila, y la nueva instancia de la función trabajará con su propia copia de las variables locales. Cuando esta segunda instancia de la función retorna, recupera las variables y los parámetros de la pila y continúa la ejecución en el punto en que había sido llamada.
Hay algunas limitaciones:
- No es posible calcular el factorial de números negativos, no está definido.
- El factorial de cero es 1.
Por ejemplo:
Podríamos crear una función recursiva para calcular el factorial de un número entero.
El factorial se simboliza como n!, se lee como "n factorial", y la definición es:
n! = n * (n-1) * (n-2) * ... * 1
Ventajas y desventajas de la Recursividad:
Ventajas:
· No es necesario definir la secuencia de pasos exacta para resolver el problema.
· Soluciones simples, claras.
· Soluciones elegantes.
· Soluciones a problemas complejos.
Desventajas:
· Podría ser menos eficiente.
· Sobrecarga asociada con las llamadas a sub algoritmos
· Una simple llamada puede generar un gran número de llamadas Recursivas. (Fact(n) genera n llamadas recursivas)
· El valor de la recursividad reside en el hecho de que se puede usar para resolver problemas sin fácil solución iterativa.
· La ineficiencia inherente de algunos algoritmos recursivos.
Un requisito importante para que sea correcto un algoritmo recursivo es que no genere una
secuencia infinita de llamadas así mismo. Claro que cualquier algoritmo que genere tal secuencia
no termina nunca. Una función recursiva f debe definirse en términos que no impliquen a f al
menos en un argumento o grupo de argumentos. Debe existir una "salida" de la secuencia de
llamadas recursivas.
Si en esta salida no puede calcularse ninguna función recursiva. Cualquier caso de definición
recursiva o invocación de un algoritmo recursivo tiene que reducirse a la larga a alguna
manipulación de uno o casos más simples no recursivos.
Ejercicio #1: Factorial de un número
#include <iostream>
using namespace std;
long double factorial(int);
int main()
{ int n;
cout << "Introduzca numero: ";
cin >> n;
cout << "factorial: " << factorial(n) << endl;
system("pause");
}
long double factorial(int n)
{
long double fact;
if (n==0)
return 1;
else
return n*factorial(n-1);
}
Ejercicio #2: Las Torres De Hanoi
# include <iostream>
using namespace::std;
// FUNCION MOVER_TORRES
void Mover_Torres(int N, int Origen, int Intermedio, int Destino)
{ // Abre funcion Mover_Torres
if (N > 1)
{ // Abre if
Mover_Torres(N - 1, Origen, Destino, Intermedio);
/* Se mueve una torre de N - 1 discos desde la columna origen
pero hacia la columna intermedia ( para dejar la destino libre)
usando la columna destino como intermedia cout << "\nMueve disco "
<< N << " de " << Origen << " a " << Destino <<endl;
con esta instrucción se mueve el disco de la base hacia su destino
Como comento arriba, ahora hay que mover nuevamente la torre de
N - 1 discos hacia el destino original ( en donde se ha puesto el
disco mayor ) Esto implica una segunda llamada recursiva. Ahora
el origen es la columna intermedia a la que se movió la torre y
el destino es el destino primitivo,lo que originalmente era el
origen se usa ahora como columna intermedia */
cout << "\nMueve el disco " << N << " de " << Origen << " a " << Destino << endl;
Mover_Torres(N - 1, Intermedio, Origen, Destino);
} // Cierra if
// El caso limite mas sencillo se resuelve directamente
if (1 == N)
cout << "\nMueve el disco 1 de " << Origen << " a " << Destino << endl;
} // Cierra funcion Mover_Torres
int main()
{ // Abre funcion main
int Discos;
cout << "\nEste programa resuelve el problema clasico de las Torres de Hanoi";
cout << " mediante la recursion." << endl;
cout << "\nPor favor introduzca el numero de discos que quiere mover ";
cout << " de la pila 1 a la pila 3" << endl;
cin >> Discos;
Mover_Torres(Discos, 1, 2, 3);
cout << endl << endl;
return 0;
system("pause");
} // Cierra funcion main
Ejercicio: Multiplicar dos números
#include <iostream>
using namespace std;
int producto(int, int);
int main()
{
int n1,n2,p;
cout << "Introduzca primer numero: ";
cin >> n1;
cout << "Introduzca segundo numero: ";
cin >> n2;
p=producto(n1,n2);
cout << "producto: " << p << endl;
system("pause");
}
int producto(int a, int b)
{
if(a==0 or b==0)
return 0;
else
{
return a+producto(a,b-1);
}
}
Gracias
Jossua Orellana G, Marcelo Olalla.
COMO INSTALAR ECLIPSE
COMO INSTALAR ECLIPSE ,CON COMPILADOR C++
PASOS
A..- INSTALACION JAVA, JDK:
java Descargar Java
-----------------------------------------------------------------------------------------------------------
jdk:
para 32 bits:
Descargar JDK32
para 64 bits:
Descargar JDK 64
-----------------------------------------------------------------------------------------------------------
B.-INSTALACIÓN DEL COMPILADOR
1.-Descargar TDM-GCC Descargar
2.-Instalar TDM*----Click en Create----click MINGW/TDM(32bits)***--**Siguiente*--finalizar
-------------------------------------------------------------------------------------------------------------
C.-INSTALACION DE ECLIPSE
1.-Descargar eclipse mars
64 bits: Descargar
32bits: Descargar
2.-Descomprimir eclipse del archivo (eclipse-cpp-mars-1-win32-x86_64.rar )en el disco local c
LISTO.
-----------------------------------------------------------------------------------------------------------
D.-CONFIGURACION
1.-Abrir eclipse ubicado en el disco c .--------Seleccionar la carpeta que se utilizara para guardar los proyectos de eclipse.-----click en (use this as the default and do not ask again)
2.-dar click en windows----->Preferences------->seleccionar general luego en la lista desglozada seleccionar workspace----
**En la pestaña de Workspace
en el recuadro de (text file encoding )click--->en other---luego seleccionar (UTF-8)
en el recuadro de (New text file line delimiter )click--->en other--luego seleccionar(unix)
**En el panel de la izquierda seleccionar C/C++-----luego en New C/C+ Project------Seleccionar Empty Project-----Seleccionar MINGW CC y dar lick en (Make toolchain(s) preferred) y finalmente clicken OK listo.
SILABUS
PROGRAMA DE ASIGNATURA PROGRAMACIÓN I – SÍLABO-
PRESENCIAL
1.
DATOS
INFORMATIVOS
MODALIDAD:
Presencial
|
DEPARTAMENTO:
Ciencias de la Computación
|
ÁREA DE
CONOCIMIENTO:
Programación
|
||
CARRERAS:
Sistemas, Mecánica
|
NOMBRES
ASIGNATURA:
Programación I
|
PERÍODO
ACADÉMICO:
Octubre
2015 – Febrero 2016
|
||
PRE-REQUISITOS:
Fundamentos de Programación
|
CÓDIGO:
15081
|
NRC:
|
No. CRÉDITOS:
6
|
NIVEL:
Segundo
|
CO-REQUISITOS:
|
FECHA
ELABORACIÓN:
31/08/2015
|
SESIONES/SEMANA:
|
EJE
DE FORMACIÓN
Profesional
|
|
TEÓRICAS:
1 H
|
LABORATORIOS:
5 H
|
|||
DOCENTE:
|
||||
DESCRIPCIÓN
DE
El crecimiento de la industria del Software
permite que el estudiante innove nuevas habilidades, destrezas utilizando
diferentes técnicas de manipulación de información basados en métodos con
programación funcional y /u orientada a objetos en búsqueda de nuevas
alternativas de solución y automatización de programas bases apoyados en el
conocimiento e implementación de técnicas avanzadas de programación
estructurada, Programación Orientad a Objetos con sus diferentes
funcionalidades.
|
||||
CONTRIBUCIÓN
DE LA ASIGNATURA A LA FORMACIÓN PROFESIONAL:
Desarrolla programas informáticos empleando
programación avanzada con creatividad
e innovación para la resolución de problemas computacionales usando técnicas
y mecanismos de programación con razonamiento matemático y lógico en búsqueda
de soluciones informáticas.
|
||||
RESULTADO DE
APRENDIZAJE DE LA CARRERA: (UNIDAD DE
COMPETENCIA)
Desarrolla proyectos de sistemas
de información aplicando ingeniería de software y estándares que garanticen
la calidad del producto, liderando grupos de trabajo con creatividad,
eficiencia, eficacia y responsabilidad
profesional.
|
||||
OBJETIVO DE LA ASIGNATURA:
Aplicar conceptos, técnicas y herramientas para el diseño, desarrollo y
ejecución de programas informáticos, utilizando programación modular y
orientada a objetos en búsqueda de automatización a los procesos manuales.
|
||||
RESULTADO DE
APRENDIZAJE DE LA ASIGNATURA: (ELEMENTO
DE COMPETENCIA)
1. Realiza el análisis de requisitos del sistema
de información
3. Modela y diseña los sistemas de información.
4. Construye, prueba e implanta los sistemas de información en diferentes
plataformas
|
||||
2.
SISTEMA DE
CONTENIDOS Y RESULTADOS DEL APRENDIZAJE
No.
|
UNIDADES DE CONTENIDOS
|
RESULTADOS DEL
APRENDIZAJE Y SISTEMA DE TAREAS
|
1
|
UNIDAD 1:
TÉCNICAS
AVANZADAS PROGRAMACIÓN ESTRUCTURADA
|
Resultados de Aprendizaje de la Unidad1:
Desarrollar programas computacionales con características modulares
|
Contenidos:
1.1. Presentación, indicaciones generales
1.2.
Arreglos: definición, declaración, acceso a elementos.
1.3.
Punteros: definición, declaración, operadores, aritmética de punteros,
punteros a cadenas.
1.4.
Relación entre arreglos y punteros. Aplicaciones que usan indexación y aritmética
de punteros.
1.5.
Funciones: definición, declaración, llamadas a función parámetros por valor, dirección y referencia.
1.6.
Paso de arreglos y punteros como parámetros.
1.7.
Funciones que devuelven un puntero.
1.8.
Punteros a función.
1.9.
Funciones recursivas
1.10.
Estructuras: definición, declaración, acceso a elementos.
1.11.
Tipos de datos abstractos.
1.12. Arreglos
dentro de una estructura.
1.13. Arreglos
de estructuras.
1.14. Paso de estructuras como parámetros
1.15. Estructuras anidadas.
1.16. Enum, Uniones.
1.17.
Asignación dinámica de memoria: funciones
malloc () y free(). Operadores new y delete.
1.18.
Arreglos dinámicos de estructuras.
|
Tarea 1:
Creación de un programa utilizando prototipos.
Tarea 2:
Elaboración de programas usando punteros.
Tarea3:
Informe de representación de prototipos y funciones en el lenguaje C++.
Tarea 4:
Desarrollo de aplicaciones utilizando el lenguaje de programación C++,
implementando funciones.
Tarea 5:
Resolución de Problemas aplicando arreglos.
Tarea 6:
Resolución de Problemas Aplicando estructuras
Tarea 7:
Resolución
de problemas utilizando memoria dinámica.
|
|
2
|
UNIDAD 2:
ORIENTACIÓN
A OBJETOS
|
Resultados de Aprendizaje de la Unidad 2:
Desarrollar programas computacionales basados en manejo de memoria
dinámica
|
Contenidos:
2.1.
Introducción a la programación orientada a objetos (POO). Principios
fundamentales de la POO.
2.2.
Definiciones de clases, objetos, atributos, métodos y mensajes.
2.3.
Especificaciones de acceso (private, protected y public).
2.4.
Funciones inline. Archivos fuente de definición (cabecera .h) e
implementación (.cpp).
2.5.
Constructores y destructores. El puntero this.
2.6.
Getters y setters.
2.7.
Sobrecarga de funciones. Argumentos por defecto.
2.8.
Clases anidadas. Composición, agregación.
2.9.
Diagramas UML de clases.
2.10. Funciones
amigas y clases amigas.
2.11. Sobrecarga
de operadores.
2.12.
Atributos y métodos estáticos.
2.13.
Punteros a atributos y métodos.
2.14. Arreglo
de objetos: estáticos
2.15.
Arreglo de objetos: dinámicos.
|
Tarea 1:
Resolución
de Problemas sobre P.O.O.
Tarea 2:
Resolución
de problemas utilizando arreglos dinámicos
|
|
3
|
UNIDAD 3:
HERENCIA POLIMORFISMO
Y ARCHIVOS
|
Resultados de Aprendizaje de la Unidad 3:
Desarrollar
programas Orientados a Objetos con sus características funcionales
|
Contenidos:
3.1. Herencia
simple. Constructores y listas de parámetros en herencia simple. Jerarquía de
clases.
3.2. Clases
y funciones virtuales.
3.3. Herencia
múltiple. Constructores y listas de parámetros en herencia múltiple. Herencia
repetida.
3.4.
Funciones virtuales puras. Clases abstractas. Polimorfismo.
3.5. Entrada
y salidas por archivos. Apertura de archivos, creación de archivos.
3.6. Funciones
para manipulación de archivos.
|
Tarea 1:
Aplicación
utilizando herencia simple y múltiple
de ejecución simulando eventos de la vida real.
Tarea 2:
Almacenamiento
de datos en archivos planos.
Tarea 3
Aplicación
para Ingreso consulta, búsqueda,
actualización y eliminación de datos.
|
3. PROYECCIÓN METODOLÓGICA Y ORGANIZATIVA PARA EL
DESARROLLO DE LA ASIGNATURA
( PROYECCIÓN DE LOS MÉTODOS DE ENSEÑANZA-APRENDIZAJE QUE SE
UTILIZARÁN)
Conforme al modelo educativo de la ESPE, centrado principalmente en el
estudiante (aprendizaje), se privilegia una metodología con enfoque
constructivista a través de la participación constante, el trabajo
cooperativo y la permanente vinculación entre la teoría y la práctica.
La asignatura se impartirá mediante clases teórico prácticas con
sesiones de dos horas de duración, 6 sesiones en la semana. De acuerdo con la
naturaleza del curso, sus contenidos serán desarrollados en diferentes
niveles de aprendizaje desde la adquisición de conocimientos básicos, su
aplicación, análisis, síntesis y evaluación a través de actividades diseñadas
para mejorar su aprendizaje.
Adicionalmente, se utilizarán las siguientes estrategias:
•
Clase
magistral.
•
Análisis
de casos particulares.
•
Prácticas
de laboratorio.
•
Talleres
y ejercicios prácticos.
•
Aplicación
de lo aprendido en un proyecto por unidad.
El curso será evaluado de la siguiente manera:
Unidad 1- 2 – 3
•
El
estudiante deberá elaborar programas considerando la temática analizada para
lograr el RDA 1.
•
Portafolio
de Ejercicios: El estudiante deberá resolver los ejercicios planteados por el
docente y subirlos a la plataforma virtual. Se adjunta rúbrica.
•
Documentación
del proyecto a desarrollar: Por equipo de trabajo los estudiantes deberán
generar la documentación para la gestión del proyecto seleccionado, la cual
incluye propuestas de proyecto, informe de selección de proyecto, acta de
constitución, planes de gestión del proyecto y solución del proyecto. Esta calificación considera nota grupal y
nota individual, la nota individual depende de la calificación entre pares de
estudiantes y de la defensa individual del trabajo realizado en la Unidad 3.
•
Portafolio
de lecciones aprendidas: El estudiante deberá desarrollar un blog con
lecciones aprendidas, el cual deberá ser actualizado según el avance de la
materia.
•
Cuestionarios
y Pruebas: El estudiante rendirá evaluaciones prácticas y teóricas.
Resolución de problemas para los temas en búsqueda de los objetivos de los
RDA 1, 2 y 3. Para esta nota también serán considerados los controles de
lectura que asigna el docente.
•
Examen:
El estudiante rendirá una evaluación final que considera el contenido
estudiado en las unidades 1 y 2.
•
Informes
y exposición de Investigación: Los estudiantes deberán investigar, sintetizar
y realizar una presentación del tema enviado por el docente en equipos de
trabajo. El informe y presentación
deberán subirse a la plataforma virtual. Se adjunta rúbrica.
•
Debates:
El docente plantea temas complementarios a las sesiones presenciales, cuyas
aportaciones serán ubicadas en la plataforma virtual.
Asistencia:
·
Se
tomará lista en cada sesión de clase.
|
PROYECCIÓN DEL EMPLEO DE
LAS TIC EN LOS PROCESOS DE APRENDIZAJE
El crecimiento de la industria del Software
permite que el estudiante innove
nuevas habilidades, destrezas utilizando diferentes técnicas de manipulación
de información basados en herramientas que logren los objetivos deseados
tales como manejo de herramientas de programación como C++ en sus diferentes
IDE: CodeBlocks, Borland C, Dev, Visual Studio; creación de Blog, Wikis y
foros usando la plataforma existente en la institución como es e-ducativa.
|
4. RESULTADOS DEL APRENDIZAJE, CONTRIBUCIÓN AL PERFIL DE EGRESO Y TÉCNICA DE
EVALUACIÓN
LOGRO O
RESULTADOS DE APRENDIZAJE
|
NIVELES DE LOGRO
|
Técnica
de evaluación
|
Evidencia
del aprendizaje
|
||
A
Alta
|
B
Media
|
C
Baja
|
|||
1) Desarrollo programas
computacionales con características modulares
|
X
|
Resolución
de prácticas de casos
|
El
estudiante deberá subir los ejercicios a la plataforma
|
||
2) Desarrolla programas Orientados a
Objetos con sus características funcionales
|
X
|
Resolución
de prácticas de casos
|
El
estudiante deberá subir los ejercicios a la plataforma
|
||
3) Desarrolla programas
computacionales basados en manejo de memoria dinámica
|
X
|
Resolución
de prácticas de casos
|
El
estudiante deberá subir los ejercicios a la plataforma
|
||
5. DISTRIBUCIÓN DEL TIEMPO
TOTAL HORAS
|
CONFERENCIAS
|
CLASES
PRÁCTICAS
|
LABORATORIOS
|
CLASES
DEBATES
|
CLASES
EVALUACIÓN
|
TRABAJO AUTÓNOMO DEL ESTUDIANTE
|
96
|
2
|
30
|
26
|
4
|
4
|
30
|
6.
TÉCNICAS
Y PONDERACIÓN DE LA EVALUACIÓN
Técnica de evaluación
|
1er Parcial*
|
2do Parcial*
|
3er Parcial*
|
Resolución de ejercicios
|
|||
Investigación Bibliográfica
|
3
|
3
|
|
Lecciones oral/escrita
|
|||
Pruebas orales/escrita
|
|||
Laboratorios
|
2
|
2
|
3
|
Talleres
|
|||
Solución de problemas
|
|||
Prácticas
|
3
|
3
|
3
|
Exposición
|
2
|
2
|
2
|
Trabajo colaborativo
|
2
|
2
|
2
|
Examen parcial
|
8
|
8
|
|
Otras formas de evaluación
|
10
|
||
Total:
|
20
|
20
|
20
|
7.
BIBLIOGRAFÍA BÁSICA/ TEXTO GUÍA DE LA ASIGNATURA
TITULO
|
AUTOR
|
EDICIÓN
|
AÑO
|
IDIOMA
|
EDITORIAL
|
1.
C/C++. Edición revisada y actualizada 2012
|
Acera García, Miguel Ángel
|
Tercera
|
2011
|
Español
|
ANAYA MULTIMEDIA
|
2.
Programación C++
|
Liberty, Jesse; Cadenhead, Rogers
|
Segunda
|
2011
|
Español
|
ANAYA MULTIMEDIA
|
3.
Fundamentos de programación C++
|
Villalobos Marcelo
|
Segunda
|
2010
|
Español
|
Macro
|
BIBLIOGRAFÍA
COMPLEMENTARIA
TITULO
|
AUTOR
|
EDICIÓN
|
AÑO
|
IDIOMA
|
EDITORIAL
|
4.
Como programar en C/C++
|
Deithel y Deithel
|
Sexta
|
2010
|
Español
|
Prentice Hall
|
8.
LECTURAS PRINCIPALES
TEMA
|
TEXTO
|
PÁGINA
|
Todos
|
Aprende a programar en C++ con nosotros
|
http://c.conclase.net/
|
Todos
|
POO (Programación
Orientada a objetos)
|
http://www.ciberaula.com/articulo/tecnologia_orientada_objetos/
|
Descarga de libro, con licencia CC
|
Programación Orientada a Objetos
|
http://www.libreriaalvaro.com/libropoo.pdf
|
9.
ACUERDOS
DEL DOCENTE:
·
Estar puntuales a las
clases, no se permitirá el ingreso de los estudiantes con retraso mayor a 15
minutos.
·
Apagar los celulares.
·
Se realizará prácticas
de laboratorio grupales por semana.
·
Las pruebas y los
exámenes serán aplicados en la fecha y hora fijada por el docente y en
conocimiento de los estudiantes.
·
Se controlará el
plagio.
·
Trabajar las
actividades propuestas en el aula virtual
·
La autoridad del
docente se limita a su materia por lo que los compromisos extraoficiales que él
contraiga no representan la postura oficial de la administración de la carrera.
·
Brindar respeto y
consideración a los alumnos y dirigir sus clases con el mejor ambiente de
trabajo y colaboración, fomentando la investigación y el trabajo en equipo
·
Si es detectada la poca
o ninguna participación en las actividades grupales de algún miembro de los
equipos de trabajo y esto no es reportado por ellos mismos, se asumirá
complicidad de ellos y serán sancionados con la nota de cero en todo el trabajo
final (implica la pérdida del curso) dado el peso ponderado del trabajo en la
nota final.
DE LOS ESTUDIANTES:
·
Asistir puntualmente a
clases.
·
No realizar copia de
exámenes, pruebas, informes, proyectos, capítulos, ensayos, entre otros, será
severamente corregida, inclusive podría ser motivo de la pérdida automática del
semestre, (código de ética de la ESPE).
·
Respeto en las
relaciones docente- alumno y alumno-alumno será exigido en todo momento, esto
será de gran importancia en el desarrollo de las discusiones en clase.
·
En los trabajos se
deberán incluir las citas y referencias de los autores consultados (de acuerdo
a normativas aceptadas, APA). Si un
plagio es evidenciado, podría ser motivo de la separación del curso del o los
involucrados.
·
Los casos y trabajos
asignados deberán ser entregados el día correspondiente.
·
Apagar el celular.
·
Desarrollar las
prácticas de laboratorio
·
Realizar las pruebas y los exámenes en la fecha y
hora.
·
Trabajar las
actividades propuestas en el aula virtual
10.
FIRMAS DE LEGALIZACIÓN:
_______________________________
_______________________________________
DOCENTE COORDINADOR DE ÁREA DE
Ing. Fausto Meneses CONOCIMIENTOS
Sr. Ing. Fernando Solís
_______________________________
_______________________________________
PLANIFICADOR
DE DEPARTAMENTO DIRECTOR DE DEPARTAMENTO/CARRERA
Sr. Ing. Paúl Díaz Sr. Crnl. EMC (S.P.) Ing. Fidel
Castro
Suscribirse a:
Entradas (Atom)