À propos de ce cours : The final course in the specialization Introduction to Programming in C will teach you powerful new programming techniques for interacting with the user and the system and dynamically allocating memory. You will learn more sophisticated uses for pointers, such as strings and multidimensional arrays, as well as how to write programs that read and write files and take input from the user. Learning about dynamic memory allocation will allow your programs to perform complex tasks that will be applied in the final part of the specialization project: a Monte Carlo simulation for calculating poker hand probabilities.
Les destinataires de ce cours : This course is for learners who have an interest in learning how to program, for people with no programming experience or for people with some experience who would like to gain solid fundamentals and a deeper understanding of how to program effectively.
Créé par : Université Duke
Enseigné par : Andrew D. Hilton, Assistant Professor of the Practice
Electrical and Computer Engineering
Enseigné par : Anne Bracy, Senior Lecturer
Computer Science, Cornell University
Enseigné par : Genevieve M. Lipp, Adjunct Professor
Electrical and Computer Engineering/Mechanical Engineering
| Informations de base | Cours 4 de 4 dans Introduction to Programming in C Specialization |
| Niveau | Beginner |
| Engagement | 4 weeks of study, 6–8 hours/week |
| Langue | English |
| Comment réussir | Réussissez tous les devoirs notés pour terminer le cours. |
Programme de cours
SEMAINE 1
Module 1: Interacting with the user and system
So far, our programs have had a rather limited interaction with the user or rest of the system, printing some results to standard output (typically to the terminal). Now that we have learned about topics such as strings and arrays, we are ready to learn how to write a program that takes input from the user, takes arguments on the command line, accesses files, and does many other things we typically think of real programs as doing.
5 vidéos, 16 lectures, 4 quiz pour s'exercer
- Vidéo: Why We Need Interactivity and to Manage Memory
- Leitura: Assignment 24_read_arr3
- Leitura: Introduction to the Operating System
- Leitura: Errors from System Calls
- Teste para praticar: The Operating System
- Leitura: Command Line Arguments
- Leitura: Complex Option Processing
- Leitura: The Environment Pointer
- Leitura: Process Creation
- Teste para praticar: Command Line Arguments and Process Creation
- Leitura: Opening a File
- Leitura: Reading a File
- Vidéo: Reading a File with fgetc
- Teste para praticar: Opening Files and fgetc
- Leitura: Reading a File with fgets
- Vidéo: Reading a File with fgets
- Leitura: Reading a File with fread
- Leitura: Assignment 25_break_encr
- Leitura: Writing to Files
- Vidéo: Writing to a File
- Leitura: Closing Files
- Vidéo: Closing a File
- Leitura: Other Interactions
- Teste para praticar: Writing and Closing Files
- Leitura: Assignments 26_tests_matrix_input and 27_matrix_input
SEMAINE 2
Module 2: Dynamic allocation
So far, most of the memory we have used has been located on the stack. Dynamic memory allocation gives a programmer much more flexibility, in that it allows you to request a specific amount memory to be allocated on the heap, so that it will not disappear with the stack frame of the calling function.
7 vidéos, 19 lectures, 5 quiz pour s'exercer
- Leitura: Motivation for Dynamic Allocation
- Leitura: malloc
- Vidéo: Simple Call to malloc
- Leitura: Fixing initArray
- Leitura: More Complex Structures
- Leitura: Shallow vs. Deep Copying
- Teste para praticar: malloc
- Leitura: free
- Vidéo: Mechanics of free
- Leitura: Memory Leaks
- Vidéo: Code with a Memory Leak
- Leitura: A Dynamic Memory Allocation Analogy
- Leitura: Common Problems with free
- Vidéo: Three Common Problems When Using free
- Teste para praticar: free
- Leitura: realloc
- Vidéo: Call to realloc
- Teste para praticar: realloc
- Leitura: getline
- Vidéo: Reading a File with getline
- Vidéo: Combining getline and realloc
- Teste para praticar: getline
- Leitura: Valgrind's Memcheck
- Leitura: Uninitialized Values
- Leitura: Invalid Reads and Writes
- Leitura: Valgrind with GDB
- Leitura: Dynamic Allocation Issues
- Leitura: memcheck.h
- Leitura: Other Valgrind Tools
- Teste para praticar: Valgrind's Memcheck
- Leitura: Assignments 28_fix_vg_encr, 29_outname, 30_sort_lines, and 31_minesweeper
SEMAINE 3
Module 3: Programming in the Large
So far, we have focused exclusively on programming in the small—designing the algorithm for a small-sized task, implementing it, testing it, and debugging it. This module discusses three main differences that "real" programs exhibit. 1) They tend to be much larger than those we have written. 2) More than one person works on them, sometimes teams of hundreds to thousands. 3) Real software has a long life-span during which it must be maintained. Now that you have an understanding of the basics of programming in the small, we are ready to begin learning about programming in the large!
2 vidéos, 21 lectures, 2 quiz pour s'exercer
- Vidéo: Introduction
- Leitura: Analogy to Writing
- Leitura: Abstraction
- Leitura: The Seven-Item Limit
- Leitura: Hierarchical Abstraction
- Teste para praticar: Abstraction
- Leitura: Readability
- Leitura: Function Size
- Leitura: Naming
- Leitura: Formatting
- Leitura: Commenting and Documentation
- Teste para praticar: Readability
- Leitura: Team Considerations
- Leitura: Git
- Leitura: Past Versions
- Leitura: Collaboration
- Leitura: Multiple Versions of the Present
- Leitura: Read More
- Leitura: Problem Description
- Vidéo: Roster Planning
- Leitura: Planning the High-Level Algorithm
- Leitura: Writing and Testing readInput
- Leitura: Finishing the Program
- Leitura: Even Larger Programs
- Leitura: Assignments 32_kvs, 33_counts, and 34_put_together
SEMAINE 4
Module 4: Poker Project
In this module, you will complete the Poker Project! Now that you know about dynamic memory allocation, user input, and how to program in the large, you can write the final parts of the program. You will write code to read in a file with a hand of cards and code to choose unknown cards from a shuffled deck. As you program with more sophisticated data structures, the importance of drawing good pictures will increase. Happy programming!
1 vidéo, 1 lecture
- Vidéo: Poker Project: Final Part
- Leitura: Poker Project: Final Part
Noté: Practice Programming Environment
FAQ
Comment cela fonctionne
Trabalho
Cada curso é como um livro didático interativo, com vídeos pré-gravados, testes e projetos.
Ajuda dos seus colegas
Conecte-se com milhares de outros aprendizes, debata ideias, discuta sobre os materiais do curso e obtenha ajuda para dominar conceitos.
Certificados
Obtenha reconhecimento oficial pelo seu trabalho e compartilhe seu sucesso com amigos, colegas e empregadores.
Créateurs
Université Duke
Duke University has about 13,000 undergraduate and graduate students and a world-class faculty helping to expand the frontiers of knowledge. The university has a strong commitment to applying knowledge in service to society, both near its North Carolina campus and around the world.
Tarification
| Acheter le cours | |
|---|---|
| Accéder au contenu du cours | Disponible |
| Accéder au contenu noté | Disponible |
| Recevoir une Note Finale | Disponible |
| Obtenir un Certificat de Cours partageable | Disponible |
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2018 Coursera Inc. Tous droits réservés.
