New Building Website

CSA 153 Introduction to C/C++ Programming (3 credits)

Catalog description:

Introduction to the use of the C/C++ programming language as an aid to solving mathematical and scientific problems. Students design, write, and implement programs.

Prerequisite: None.

Course Objectives:

  • To learn the fundamental programming concepts and methodologies which are essential to building good C programs.
  • To practice the fundamental programming methodologies in the C programming language via laboratory experiences. ANSI C in the Turbo C++ environment is the tool that will used.
  • To code, document, test, and implement a well-structured, robust computer program using the C programming language.
  • To write reusable modules.

CSA 153 is a first-tier course in the CSA4 "Web and Game Applications" thematic sequence.

Given the prevalence of computing devices, it is important that we understand what computers do and how they do it. The web game applications thematic sequence is designed to provide students with an understanding of how computer software is created and designed and how it functions to make possible popular applications such as computer games and the World Wide Web. Courses in the sequence provide an introduction to fundamental programming concepts.  These concepts are applied to create computer games and web applications.

The CSA4 thematic sequence consists of one of the following introductory computer programming courses...

  • CSA 153, Introduction to C/C++ Programming
  • CSA 163, Introduction to Computer Concepts and Programming
  • CSA 174, Fundamentals of Programming and Problem Solving

Followed by both of the following courses...

  • CSA 251, Introduction to Game Programming
  • CSA 252, Web Application Programming

CSA 153 is a course in which you learn computer programming concepts that are fundamental in nearly any computer programming language.  These concepts can then be used in other courses to help you create computer applications that can be used to solve real-world problems.

Learning Outcomes

Below are the learning outcomes for this course. Miami Plan foundation courses and thematic sequence courses address some or all of the Four Principles of Liberal Education: Thinking Critically, Understanding Contexts, Engaging with Other Learners, and Reflecting and Acting. These principles are not simply additional "topics" that are covered during the course. Rather, they are perspectives and ways of reasoning that are essential to all the content of the course. Learning outcomes that address these principles are indicated in the table. Liberal Education Principles (LEP) Key: T=Thinking Critically, U=Understanding Contexts

Learning Outcomes:

LEP

CSA 153.1: To describe the advantages of a high level language like C/C++, the programming process, and the compilation process
CSA 153.1.1     Describe and compare machine language and a high level language
CSA 153.1.2     Discuss the advantages of a high-level language (e.g. human readable, portability)
CSA 153.1.3     Distinguish between source code, object code and executable code
CSA 153.1.4     Describe the function of the compiler in the language translation process

T

CSA153.2: To describe and use software tools in the programming process
CSA 153.2.1     Describe the functions of an IDE (e.g. editor, compiler, debugger)
CSA 153.2.2     Use an IDE to compile, load, save, and debug a C/C++ program

 

CSA 153.3: To apply good programming principles to the design and implementation of C/C++ programs
CSA153.3.1      Demonstrate an understanding of algorithms in the problem-solving process
CSA153.3.2      Identify the necessary properties of good problem-solving techniques
CSA153.3.3      Create and analyze algorithms for solving simple problems
CSA153.3.4      Use incremental program development to create, test, and debug algorithms for solving simple problems
CSA153.3.5      Write readable code that follows accepted style and documentation guidelines
CSA153.3.6      Apply techniques of structured (functional) decomposition to decompose problem and a program solution into smaller pieces
CSA153.3.7      Create and call functions that use parameter passing and return values.
CSA153.3.8      Design and implement code that includes the reuse of both existing code and calling    functions in the C/C++ libraries

T, U

CSA153.4:       To design, implement, debug and test programs using the fundamental elements of C/C++
CSA153.4.1:     Demonstrate an understanding of the overall syntax and semantics of C/C++ programs by writing small programs from specifications given in class
CSA153.4.2      Describe the fundamental components of a C/C++ program (e.g. source files, header files, main() function, functions, and libraries)
CSA153.4.3      Explain and apply fundamental syntax rules for identifiers, declarations, expressions, statements, and functions
CSA153.4.4      Demonstrate an understanding of scope, lifetime and duration rules for variables and functions
CSA153.4.5      Analyze, explain and trace the behavior of simple programs involving the fundamental programming constructs addressed in the course
CSA153.4.6      Modify and extend short programs that use standard conditional and iterative control structures and functions
CSA153.4.7      Write programs that use each of the following fundamental programming constructs: basic computations, simple console I/O, standard conditional and iterative structures (including pretest and posttest loops, counter-controlled loops, and conditionals)
CSA153.4.8      Choose appropriate conditional and iterative constructs for a given programming task
CSA153.4.9      Debug and test programs in order to determine that the program performs as expected: Demonstrate the ability to create test cases to determine that a solution produces expected outputs for given inputs
CSA153.4.10    Test user input for erroneous values

T

CSA153.5:         To demonstrate an understanding of primitive data types, values, operators and expressions in C/C++
CSA153.5.1      Discuss the representation and appropriate use of primitive data types
CSA153.5.2      Select appropriate primitive data types for solving a variety of problems (e.g, integer,   real, character and string data)
CSA153.5.3      Demonstrate the use of arithmetic and relational operators including operator    precedence and the use of parentheses
CSA153.5.4      Describe automatic type conversion rules, related issues of magnitude and precision,  type casting, and determine the value and type of an expression involving mixed types
CSA153.5.5      Demonstrate the use of numeric arrays and c-style strings.
CSA153.5.6      Trace the execution of source code containing pointers

 

Required topics (approximate weeks allocated):

  • Computers and problem solving (.5)
    • software development methodology
  • Structure of a C++ program (.5)
  • C++ building blocks (1)
    • defining variables, data types
    • arithmetic, assignment, increment, decrement operators and operations
    • elementary input/output
  • Debugging in C++ (.5)
  • Introduction to C++ functions (1.5)
    • function structure
    • functions that return a single value
    • performing calculations in functions
    • using simple library functions
  • Pretest and posttest loops (1.5)
    • for loop
    • while loop
    • do while loop
    • nesting loops
  • Decisions (1.5)
    • logical expressions and operators
    • if statements
    • switch statement
    • nested if statements
  • Functions with arguments (1.5)
    • input arguments
    • output arguments
    • function scope
  • Using functions to build larger programs (1)
    • preprocessor
    • header files
    • prototyping
  • Building a personal library of functions (1)
    • data validation/input functions
    • specialized calculation functions
    • output functions
    • testing individual functions with a test driver
  • Representation and conversion of data types (.5)
  • Array processing (1)
  • String processing (1)
  • Introduction to pointers (1)
    • address operator
    • indirection operator
    • defining pointer variables
    • manipulating pointer variables
  • Tests/Review (1)