├── .gitignore ├── LICENSE ├── Makefile ├── README.md ├── c-lecture.cls ├── lecture-1 ├── img │ ├── 1995parham-logo.png │ ├── assembly.jpg │ ├── basic.png │ ├── build-flow.png │ ├── code-progress.png │ ├── cycle.png │ ├── flowchart.png │ ├── ieee-754.png │ ├── sw-and-hw.png │ └── torvalds.png ├── latexmkrc └── main.tex ├── lecture-10 ├── img │ ├── dijkstra.jpg │ └── null-empty-string.png ├── latexmkrc └── main.tex ├── lecture-11 ├── img │ ├── ll-1.png │ ├── ll-2.png │ ├── rob.jpg │ └── union.png ├── latexmkrc ├── main.tex └── src │ └── union-size.c ├── lecture-12 ├── img │ └── yoda.jpg ├── latexmkrc └── main.tex ├── lecture-13 ├── latexmkrc └── main.tex ├── lecture-14 ├── latexmkrc └── main.tex ├── lecture-2 ├── img │ └── dennis.jpg ├── latexmkrc └── main.tex ├── lecture-3 ├── img │ └── van.jpg ├── latexmkrc └── main.tex ├── lecture-4 ├── img │ └── ken.jpg ├── latexmkrc └── main.tex ├── lecture-5 ├── img │ └── ghodsi.jpg ├── latexmkrc ├── main.tex └── src │ ├── pi.c │ └── read-with-whitespaces.c ├── lecture-6 ├── img │ ├── c-precedence.png │ └── coronavirus.jpg ├── latexmkrc ├── main.tex └── src │ └── boolean.c ├── lecture-7 ├── img │ └── nowruz.jpg ├── latexmkrc ├── main.tex └── src │ ├── do-while-read.c │ └── init_with_zero.c ├── lecture-8 ├── img │ ├── pass-by-reference-vs-pass-by-value-animation.gif │ ├── pass-by-value.png │ └── stallman.jpg ├── latexmkrc ├── main.tex └── src │ ├── goldbach.c │ ├── scope.c │ └── static.c └── lecture-9 ├── img ├── arrays-in-memory.png ├── binary-search.png └── uncle-bob.png ├── latexmkrc ├── main.tex └── src └── bsearch.c /.gitignore: -------------------------------------------------------------------------------- 1 | ## Core latex/pdflatex auxiliary files: 2 | *.aux 3 | *.lof 4 | *.log 5 | *.lot 6 | *.fls 7 | *.out 8 | *.toc 9 | *.fmt 10 | *.fot 11 | *.cb 12 | *.cb2 13 | .*.lb 14 | 15 | ## Intermediate documents: 16 | *.dvi 17 | *.xdv 18 | *-converted-to.* 19 | # these rules might exclude image files for figures etc. 20 | *.ps 21 | *.eps 22 | *.pdf 23 | 24 | ## Generated if empty string is given at "Please type another file name for output:" 25 | .pdf 26 | 27 | ## Bibliography auxiliary files (bibtex/biblatex/biber): 28 | *.bbl 29 | *.bcf 30 | *.blg 31 | *-blx.aux 32 | *-blx.bib 33 | *.run.xml 34 | 35 | ## Build tool auxiliary files: 36 | *.fdb_latexmk 37 | *.synctex 38 | *.synctex(busy) 39 | *.synctex.gz 40 | *.synctex.gz(busy) 41 | *.pdfsync 42 | 43 | ## Build tool directories for auxiliary files 44 | # latexrun 45 | latex.out/ 46 | 47 | ## Auxiliary and intermediate files from other packages: 48 | # algorithms 49 | *.alg 50 | *.loa 51 | 52 | # achemso 53 | acs-*.bib 54 | 55 | # amsthm 56 | *.thm 57 | 58 | # beamer 59 | *.nav 60 | *.pre 61 | *.snm 62 | *.vrb 63 | 64 | # changes 65 | *.soc 66 | 67 | # comment 68 | *.cut 69 | 70 | # cprotect 71 | *.cpt 72 | 73 | # elsarticle (documentclass of Elsevier journals) 74 | *.spl 75 | 76 | # endnotes 77 | *.ent 78 | 79 | # fixme 80 | *.lox 81 | 82 | # feynmf/feynmp 83 | *.mf 84 | *.mp 85 | *.t[1-9] 86 | *.t[1-9][0-9] 87 | *.tfm 88 | 89 | #(r)(e)ledmac/(r)(e)ledpar 90 | *.end 91 | *.?end 92 | *.[1-9] 93 | *.[1-9][0-9] 94 | *.[1-9][0-9][0-9] 95 | *.[1-9]R 96 | *.[1-9][0-9]R 97 | *.[1-9][0-9][0-9]R 98 | *.eledsec[1-9] 99 | *.eledsec[1-9]R 100 | *.eledsec[1-9][0-9] 101 | *.eledsec[1-9][0-9]R 102 | *.eledsec[1-9][0-9][0-9] 103 | *.eledsec[1-9][0-9][0-9]R 104 | 105 | # glossaries 106 | *.acn 107 | *.acr 108 | *.glg 109 | *.glo 110 | *.gls 111 | *.glsdefs 112 | *.lzo 113 | *.lzs 114 | 115 | # uncomment this for glossaries-extra (will ignore makeindex's style files!) 116 | # *.ist 117 | 118 | # gnuplottex 119 | *-gnuplottex-* 120 | 121 | # gregoriotex 122 | *.gaux 123 | *.gtex 124 | 125 | # htlatex 126 | *.4ct 127 | *.4tc 128 | *.idv 129 | *.lg 130 | *.trc 131 | *.xref 132 | 133 | # hyperref 134 | *.brf 135 | 136 | # knitr 137 | *-concordance.tex 138 | # TODO Comment the next line if you want to keep your tikz graphics files 139 | *.tikz 140 | *-tikzDictionary 141 | 142 | # listings 143 | *.lol 144 | 145 | # luatexja-ruby 146 | *.ltjruby 147 | 148 | # makeidx 149 | *.idx 150 | *.ilg 151 | *.ind 152 | 153 | # minitoc 154 | *.maf 155 | *.mlf 156 | *.mlt 157 | *.mtc[0-9]* 158 | *.slf[0-9]* 159 | *.slt[0-9]* 160 | *.stc[0-9]* 161 | 162 | # minted 163 | _minted* 164 | *.pyg 165 | 166 | # morewrites 167 | *.mw 168 | 169 | # nomencl 170 | *.nlg 171 | *.nlo 172 | *.nls 173 | 174 | # pax 175 | *.pax 176 | 177 | # pdfpcnotes 178 | *.pdfpc 179 | 180 | # sagetex 181 | *.sagetex.sage 182 | *.sagetex.py 183 | *.sagetex.scmd 184 | 185 | # scrwfile 186 | *.wrt 187 | 188 | # sympy 189 | *.sout 190 | *.sympy 191 | sympy-plots-for-*.tex/ 192 | 193 | # pdfcomment 194 | *.upa 195 | *.upb 196 | 197 | # pythontex 198 | *.pytxcode 199 | pythontex-files-*/ 200 | 201 | # tcolorbox 202 | *.listing 203 | 204 | # thmtools 205 | *.loe 206 | 207 | # TikZ & PGF 208 | *.dpth 209 | *.md5 210 | *.auxlock 211 | 212 | # todonotes 213 | *.tdo 214 | 215 | # vhistory 216 | *.hst 217 | *.ver 218 | 219 | # easy-todo 220 | *.lod 221 | 222 | # xcolor 223 | *.xcp 224 | 225 | # xmpincl 226 | *.xmpi 227 | 228 | # xindy 229 | *.xdy 230 | 231 | # xypic precompiled matrices and outlines 232 | *.xyc 233 | *.xyd 234 | 235 | # endfloat 236 | *.ttt 237 | *.fff 238 | 239 | # Latexian 240 | TSWLatexianTemp* 241 | 242 | ## Editors: 243 | # WinEdt 244 | *.bak 245 | *.sav 246 | 247 | # Texpad 248 | .texpadtmp 249 | 250 | # LyX 251 | *.lyx~ 252 | 253 | # Kile 254 | *.backup 255 | 256 | # gummi 257 | .*.swp 258 | 259 | # KBibTeX 260 | *~[0-9]* 261 | 262 | # TeXnicCenter 263 | *.tps 264 | 265 | # auto folder when using emacs and auctex 266 | ./auto/* 267 | *.el 268 | 269 | # expex forward references with \gathertags 270 | *-tags.tex 271 | 272 | # standalone packages 273 | *.sta 274 | 275 | # Makeindex log files 276 | *.lpz 277 | 278 | # Created by https://www.toptal.com/developers/gitignore/api/c 279 | # Edit at https://www.toptal.com/developers/gitignore?templates=c 280 | 281 | ### C ### 282 | # Prerequisites 283 | *.d 284 | 285 | # Object files 286 | *.o 287 | *.ko 288 | *.obj 289 | *.elf 290 | 291 | # Linker output 292 | *.ilk 293 | *.map 294 | *.exp 295 | 296 | # Precompiled Headers 297 | *.gch 298 | *.pch 299 | 300 | # Libraries 301 | *.lib 302 | *.a 303 | *.la 304 | *.lo 305 | 306 | # Shared objects (inc. Windows DLLs) 307 | *.dll 308 | *.so 309 | *.so.* 310 | *.dylib 311 | 312 | # Executables 313 | *.exe 314 | *.out 315 | *.app 316 | *.i*86 317 | *.x86_64 318 | *.hex 319 | 320 | # Debug files 321 | *.dSYM/ 322 | *.su 323 | *.idb 324 | *.pdb 325 | 326 | # Kernel Module Compile Results 327 | *.mod* 328 | *.cmd 329 | .tmp_versions/ 330 | modules.order 331 | Module.symvers 332 | Mkfile.old 333 | dkms.conf 334 | 335 | # End of https://www.toptal.com/developers/gitignore/api/c 336 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | lectures := $(shell find -type d -name 'lecture-*') 2 | 3 | .PHONY = clean dist 4 | 5 | all: $(lectures:%=%/main.pdf) 6 | 7 | dist: $(lectures:%=%/main.pdf) 8 | $(foreach lecture,$(lectures:%=%),cp $(lecture)/main.pdf $(lecture).pdf;) 9 | tar cvfz lectures.tar.gz $(lectures:%=%.pdf) 10 | rm $(lectures:%=%.pdf) 11 | 12 | $(lectures:%=%/main.pdf): $(lectures:%=%/main.tex) 13 | @echo "building $@" 14 | cd $(dir $@) && latexmk 15 | 16 | clean: 17 | rm $(lectures:%=%/main.pdf) 18 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # C-lecture 2 | 3 | ![GitHub repo size](https://img.shields.io/github/repo-size/1995parham-teaching/c-lecture?style=flat-square) 4 | 5 | ## Introduction 6 | 7 | C lecture presentations and sample codes which is used in Introduction to Programming course. 8 | All slides are based on [Prof.Bakhshi](https://github.com/Bahador-Bakhshi)'s slides of 9 | Introduction to Programming Course. 10 | 11 | ## Agenda 12 | 13 | - Introduction - 2 Sessions 14 | - Algorithm Design - 2 Sessions (HW1) 15 | * [Watch me](https://youtu.be/2yAZT_uDpuA) 16 | - C Programming Basics - 3 Sessions 17 | - Calculation - 2 Sessions 18 | - Interaction - 2 Sessions 19 | - Making Decisions - 2 Sessions 20 | - Repeating Statements - 2 Sessions (HW2) 21 | - Functions - 3 Sessions 22 | - Arrays - 4 Sessions 23 | - Pointers and Dynamic Memory Allocations - 4 Sessions (HW3) 24 | - Structs - 4 Sessions (HW4) 25 | - Files 26 | 27 | ## Assignments 28 | 29 | - HW1: Introduction, Algorithm Design 30 | - HW2: C Programming Basics, Calculation, Interaction, Making Decisions and Repeating Statements 31 | - HW3: Functions, Arrays and Pointers 32 | - HW4: Structs and Linked-List 33 | 34 | ## How to build a nice courses page 35 | 36 | - course image from [unsplash](https://unsplash.com/photos/mDinBvq1Sfg) 37 | - how to join [quera.ir](https://quera.ir/) 38 | - teaching assistents and how to contact them. 39 | 40 | ## Requirements 41 | 42 | To build the lectures you will need the following packages: 43 | 44 | ```sh 45 | sudo tlmgr install datetime2 fmtcount algorithm2e ifoddpage relsize tracklang 46 | ``` 47 | -------------------------------------------------------------------------------- /c-lecture.cls: -------------------------------------------------------------------------------- 1 | \ProvidesClass{c-lecture} 2 | [Parham Alvani's theme for C programming course] 3 | 4 | \RequirePackage[dvipsnames]{xcolor} 5 | \RequirePackage{booktabs} 6 | \RequirePackage{minted} 7 | \RequirePackage[useregional,calc,warn=false]{datetime2} 8 | 9 | \DTMnewdatestyle{mmyy}{% 10 | \renewcommand*{\DTMdisplaydate}[4]{\DTMmonthname{##2} ##1}% 11 | \renewcommand*{\DTMDisplaydate}{\DTMdisplaydate}% 12 | } 13 | 14 | \LoadClass[]{beamer} 15 | 16 | \usemintedstyle{one-dark} 17 | 18 | \usetheme[secheader]{Boadilla} 19 | \usecolortheme{crane} 20 | 21 | \author[Parham Alvani]{% 22 | Parham Alvani\\ 23 | \texttt{parham.alvani@gmail.com} 24 | } 25 | \title{Fundamentals of Computer and Programming} 26 | \institute[AUT]{Amirkabir University of Technology} 27 | \date{\DTMsetdatestyle{mmyy}\Today} 28 | 29 | \hypersetup{colorlinks=true,allcolors=.,urlcolor=orange} 30 | \setbeamertemplate{headline}[infolines theme] 31 | % the following command suppresses all navigation symbols 32 | \setbeamertemplate{navigation symbols}{} 33 | 34 | \AtBeginSection[] 35 | {% 36 | \begin{frame} 37 | \frametitle{Outline} 38 | \tableofcontents[currentsection] 39 | \end{frame} 40 | } 41 | -------------------------------------------------------------------------------- /lecture-1/img/1995parham-logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-1/img/1995parham-logo.png -------------------------------------------------------------------------------- /lecture-1/img/assembly.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-1/img/assembly.jpg -------------------------------------------------------------------------------- /lecture-1/img/basic.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-1/img/basic.png -------------------------------------------------------------------------------- /lecture-1/img/build-flow.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-1/img/build-flow.png -------------------------------------------------------------------------------- /lecture-1/img/code-progress.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-1/img/code-progress.png -------------------------------------------------------------------------------- /lecture-1/img/cycle.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-1/img/cycle.png -------------------------------------------------------------------------------- /lecture-1/img/flowchart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-1/img/flowchart.png -------------------------------------------------------------------------------- /lecture-1/img/ieee-754.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-1/img/ieee-754.png -------------------------------------------------------------------------------- /lecture-1/img/sw-and-hw.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-1/img/sw-and-hw.png -------------------------------------------------------------------------------- /lecture-1/img/torvalds.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-1/img/torvalds.png -------------------------------------------------------------------------------- /lecture-1/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-1/main.tex: -------------------------------------------------------------------------------- 1 | \documentclass{../c-lecture} 2 | 3 | \usepackage{algorithm2e} 4 | 5 | \subtitle{Introduction} 6 | 7 | \begin{document} 8 | 9 | \begin{frame} 10 | \titlepage{} 11 | \end{frame} 12 | \begin{frame} 13 | \frametitle{Outline} 14 | \tableofcontents{} 15 | \end{frame} 16 | 17 | \section{Introduction} 18 | 19 | \begin{frame} 20 | \frametitle{Who I am?} 21 | \centering 22 | \textbf{Parham Alvani}\\ 23 | \textbf{Ph.D. Student in Computer Networks}\\ 24 | \vfill 25 | \textit{parham [dot] alvani [at] gmail [dot] com} 26 | \end{frame} 27 | \begin{frame} 28 | \frametitle{Contact Me} 29 | \begin{itemize} 30 | \item No instant messaging 31 | \item \color{Orange} Email is Awesome 32 | \end{itemize} 33 | \end{frame} 34 | 35 | \section{What is this course?} 36 | 37 | \begin{frame} 38 | \frametitle{This Course} 39 | \begin{itemize} 40 | \item Introduction to Computer \& Programming 41 | \item How to use computers to solve our problems 42 | \begin{itemize} 43 | \item The problems are computational problems 44 | \end{itemize} 45 | \end{itemize} 46 | \end{frame} 47 | 48 | \begin{frame} 49 | \frametitle{This Course (cont’d)} 50 | \begin{itemize} 51 | \item What we learn 52 | \begin{itemize} 53 | \item Overall overview of computer organization 54 | \item Problem solving steps 55 | \begin{itemize} 56 | \item Algorithm design 57 | \item A programming language: the {\color{Orange} C} 58 | \end{itemize} 59 | \end{itemize} 60 | \end{itemize} 61 | \end{frame} 62 | 63 | \begin{frame} 64 | \frametitle{This Course (cont’d)} 65 | \begin{itemize} 66 | \item What we don’t learn 67 | \begin{itemize} 68 | \item In depth computer hardware/software details 69 | \begin{itemize} 70 | \color{Aquamarine} 71 | \item Computer Architecture 72 | \item Operating System 73 | \end{itemize} 74 | \pause% 75 | \item Most advanced algorithms 76 | \begin{itemize} 77 | \color{Aquamarine} 78 | \item Data Structure 79 | \item Algorithms 80 | \end{itemize} 81 | \pause% 82 | \item System programming using C 83 | \begin{itemize} 84 | \color{Aquamarine} 85 | \item Operating System 86 | \end{itemize} 87 | \pause% 88 | \item Other programming languages: Java, Go, etc. 89 | \begin{itemize} 90 | \color{Aquamarine} 91 | \item Advanced Programming 92 | \item Web Programming 93 | \end{itemize} 94 | \end{itemize} 95 | \end{itemize} 96 | \end{frame} 97 | 98 | \begin{frame} 99 | \frametitle{This Course (cont'd)} 100 | Steps to learn a new language (English, French, \ldots C, Java, Python, \ldots) 101 | 102 | \begin{enumerate} 103 | \item Present: what is the new language (course slide) 104 | \item Practice: how to use the new language in practice (the example) 105 | \item Produce: use the language to create a new things (Lab, HW) 106 | \end{enumerate} 107 | \end{frame} 108 | 109 | \begin{frame} 110 | \frametitle{This Course (cont'd)} 111 | Learning Programming Language 112 | 113 | \begin{itemize} 114 | \item is not a pure theoretical course (mathematics, \ldots) 115 | \begin{itemize} 116 | \item Reading, reading, reading, \ldots 117 | \end{itemize} 118 | \item is a practical course needs the product step 119 | \begin{itemize} 120 | \item Class, Reading, programming, programming, programming, \ldots 121 | \end{itemize} 122 | \end{itemize} 123 | \end{frame} 124 | 125 | \begin{frame} 126 | \frametitle{This Course (cont'd)} 127 | Course Materials 128 | \begin{itemize} 129 | \item Lecture notes (slides) are in (simple) English 130 | \end{itemize} 131 | \end{frame} 132 | \begin{frame}[allowframebreaks] 133 | \frametitle{Agenda} 134 | \begin{itemize} 135 | \item Introduction 136 | \item Algorithm Design 137 | \item Basic Concepts 138 | \item Calculations 139 | \item Interaction 140 | \item Decision 141 | \item Iteration 142 | \item Function 143 | \item Array 144 | \item Pointer 145 | \item Struct 146 | \item File 147 | \item Misc. 148 | \end{itemize} 149 | \end{frame} 150 | \begin{frame} 151 | \frametitle{Grading} 152 | Major Parts + 5\% Extra 153 | \begin{table} 154 | \begin{tabular}{cc} 155 | \toprule 156 | 157 | Midterm & 158 | 25\% \\ 159 | 160 | \midrule 161 | 162 | Final & 163 | 25\% \\ 164 | 165 | \midrule 166 | 167 | Lab & 168 | 15\% \\ 169 | 170 | \midrule 171 | 172 | Homework & 173 | 30\% \\ 174 | 175 | \midrule 176 | 177 | Project & 178 | 10\% \\ 179 | 180 | \bottomrule 181 | \end{tabular} 182 | \end{table} 183 | \end{frame} 184 | 185 | \begin{frame} 186 | \frametitle{Extra Classes} 187 | Lab + TA Classes 188 | 189 | \begin{itemize} 190 | \item Lab:\@ A practical class 191 | \item TA:\@ More details, Practical aspects, Solving HW 192 | \item Homework are not accepted after solutions 193 | \end{itemize} 194 | \end{frame} 195 | 196 | \section{Computer organization} 197 | 198 | \begin{frame} 199 | \frametitle{Computers: The Computing Machines} 200 | Computer Classififcation: 201 | \begin{itemize} 202 | \item \textbf{Supercomputers}:\@ 203 | Weather forecast, Large scale simulation, \ldots 204 | \item \textbf{Mainframe computers}:\@ 205 | The servers in large companies: Google, \ldots 206 | \item \textbf{Midsize computers}:\@ 207 | The servers in CE department 208 | \item \textbf{Micro computers (also called PC)}:\@ 209 | Our laptop 210 | \item \textbf{Pocket PCs}:\@ 211 | Our mobile phones 212 | \end{itemize} 213 | \end{frame} 214 | 215 | \begin{frame} 216 | \frametitle{Computers} 217 | \begin{itemize} 218 | \item Computers are programmable machines capable of performing calculations (computation) 219 | \item Changing program leads to different operation 220 | \item Special-purpose machines 221 | \begin{itemize} 222 | \item Calculators, game-playing machines, \ldots 223 | \end{itemize} 224 | \item General-purpose computers 225 | \begin{itemize} 226 | \item Personal computers, notebooks, \ldots 227 | \end{itemize} 228 | \end{itemize} 229 | \end{frame} 230 | 231 | \begin{frame} 232 | \frametitle{Data Units} 233 | \begin{itemize} 234 | \item Computers are digital machines 235 | \item Data processed or stored in computer is represented as two-state values 236 | \begin{itemize} 237 | \item either 1 or 0 --- BInary digiTs (BIT) 238 | \item 1 Byte = 8 bits 239 | \item 1 kilobyte (KB) = 1024 bytes 240 | \item 1 megabyte (MB) = 1024 kilobyte 241 | \item 1 gigabyte (GB) = 1024 megabyte 242 | \end{itemize} 243 | \end{itemize} 244 | \end{frame} 245 | 246 | \begin{frame} 247 | \frametitle{Data Representation/Coding} 248 | \begin{itemize} 249 | \item How to represent our data by 0--1? 250 | \item In other word, there are some 0 and 1 in the computer, what is the meaning? 251 | \item {\color{YellowOrange} Coding (Representation Standards)} 252 | \item Major (common) representations (coding) 253 | \begin{itemize} 254 | \item Integer numbers: 1, 1000, -123, 0, \ldots 255 | \item Floating point numbers: 1.1, 11.232, -12.23, \ldots 256 | \item Characters: ``A'', ``B'', ``@'', \ldots 257 | \end{itemize} 258 | \end{itemize} 259 | \end{frame} 260 | 261 | \begin{frame} 262 | \frametitle{Integer Number Coding} 263 | \begin{itemize} 264 | \item There are different representations 265 | \item One of the (simple) coding is sign-magnitude coding 266 | \begin{itemize} 267 | \item If we have $n$ bit for coding integer 268 | \item The left bit (the MSB): sign 269 | \item $n-1$ bits: magnitude 270 | \end{itemize} 271 | \end{itemize} 272 | \begin{table} 273 | \begin{tabular}{ccc} 274 | \toprule 275 | 4 & 0000 & 0100 \\ 276 | \midrule 277 | -4 & 1000 & 0100 \\ 278 | \midrule 279 | 0 & 0000 & 0000 \\ 280 | \midrule 281 | -0 & 1000 & 0000 \\ 282 | \bottomrule 283 | \end{tabular} 284 | \end{table} 285 | \end{frame} 286 | 287 | \begin{frame} 288 | \frametitle{Integer Number Coding} 289 | Two's Complement 290 | \end{frame} 291 | 292 | \begin{frame} 293 | \frametitle{Floating Point Number Coding (IEEE 754)} 294 | \begin{itemize} 295 | \item Usually, this coding pattern 296 | \item Two precisions: 297 | \begin{figure} 298 | \includegraphics[width=0.75\textwidth]{./img/ieee-754.png} 299 | \end{figure} 300 | \begin{itemize} 301 | \item Single precision: exponent: 8 bit, fraction: 23 bit 302 | \item Double precision: exponent: 11 bit, fraction: 52 bit 303 | \end{itemize} 304 | \end{itemize} 305 | \end{frame} 306 | 307 | \begin{frame} 308 | \frametitle{Character Coding} 309 | \begin{itemize} 310 | \item Common character encoding: {\color{Green} ASCII} 311 | \item 8 bits can represent 256 characters; but, 312 | \begin{itemize} 313 | \item There are so many characters (Farsi, Arabic, \ldots) 314 | \item Solution: UTF (Variable length coding) 315 | \item 0xxxxxxx: 1 byte code 316 | \item 110xxxxx 10xxxxxx: 2 byte code 317 | \item \ldots 318 | \end{itemize} 319 | \end{itemize} 320 | \end{frame} 321 | 322 | \begin{frame} 323 | \frametitle{Computer Organization} 324 | 325 | \begin{itemize} 326 | \item Major Components 327 | \begin{itemize} 328 | \item \textbf{Hardware}: 329 | Physical devices that are wired and performs basic operations 330 | \item \textbf{Software}: 331 | Set of programs that run on the hardware 332 | \end{itemize} 333 | \item Hardware 334 | \begin{itemize} 335 | \item CPU (Central Processing Unit) 336 | \item Main Memory 337 | \item Secondary Storage 338 | \item Input/output 339 | \end{itemize} 340 | \end{itemize} 341 | \end{frame} 342 | 343 | \begin{frame} 344 | \frametitle{Computer Organization} 345 | \begin{figure} 346 | \includegraphics[width=0.75\textwidth]{./img/basic.png} 347 | \end{figure} 348 | \end{frame} 349 | 350 | \begin{frame} 351 | \frametitle{Computer Organization: CPU} 352 | \begin{itemize} 353 | \item ALU (Arithmetic Logic Unit) 354 | \begin{itemize} 355 | \item Performs mathematic calculations 356 | \item Makes decision based on conditions 357 | \end{itemize} 358 | \item Special Floating Point processors 359 | \item Set of working area: Registers 360 | \item Control Unit 361 | \begin{itemize} 362 | \item Controls system operation 363 | \end{itemize} 364 | \item Operation and operands are required 365 | \begin{itemize} 366 | \item Which are provided by instructions in the main memory 367 | \end{itemize} 368 | \end{itemize} 369 | \end{frame} 370 | 371 | \begin{frame} 372 | \frametitle{Computer Organization: Main Memory} 373 | \begin{itemize} 374 | \item Ordered sequence of cells (memory cells) 375 | \item Directly connected to CPU 376 | \item All programs must be in main memory before execution 377 | \item When power is turned off, Main memory is cleared 378 | \end{itemize} 379 | \end{frame} 380 | 381 | \begin{frame} 382 | \frametitle{Computer Organization: Secondary Storage} 383 | \begin{itemize} 384 | \item Provides permanent storage for information 385 | \item Examples of secondary storages: 386 | \begin{itemize} 387 | \item Hard Disks 388 | \item Floppy Disks 389 | \item Flash/Cool/USB Disks 390 | \item CD/DVD 391 | \item Tapes 392 | \end{itemize} 393 | \end{itemize} 394 | \end{frame} 395 | 396 | \begin{frame} 397 | \frametitle{Computer Organization: Input Devices} 398 | \begin{itemize} 399 | \item Devices that feed data and programs into computers 400 | \item Examples: 401 | \begin{itemize} 402 | \item Keyboard 403 | \item Mouse 404 | \item Network Interface Card 405 | \item Joystick 406 | \item Microphone 407 | \end{itemize} 408 | \end{itemize} 409 | \end{frame} 410 | 411 | \begin{frame} 412 | \frametitle{Computer Organization: Output Devices} 413 | \begin{itemize} 414 | \item Devices that computer uses to generate results/outputs 415 | \item Examples: 416 | \begin{itemize} 417 | \item Printer 418 | \item Monitor 419 | \item Speaker 420 | \item Network Interface Card 421 | \end{itemize} 422 | \end{itemize} 423 | \end{frame} 424 | 425 | \begin{frame} 426 | \frametitle{Computer Organization: Software} 427 | \begin{itemize} 428 | \item What can do the Hardware? 429 | \begin{itemize} 430 | \item No useful operation, if there isn’t any software 431 | \item We should tell/plan/program it to do something 432 | \end{itemize} 433 | \item Software 434 | \begin{itemize} 435 | \item Programs which are designed for a specific task 436 | \end{itemize} 437 | \item Major Software types 438 | \begin{itemize} 439 | \item Operating System 440 | \item Libraries 441 | \item Applications 442 | \end{itemize} 443 | \end{itemize} 444 | \end{frame} 445 | 446 | \begin{frame} 447 | \frametitle{Computer HW \& SW Organization} 448 | \begin{figure} 449 | \includegraphics[width=0.75\textwidth]{./img/sw-and-hw.png} 450 | \end{figure} 451 | \end{frame} 452 | 453 | \begin{frame} 454 | \frametitle{Computer Organization: OS} 455 | \begin{itemize} 456 | \item OS 457 | \begin{itemize} 458 | \item 459 | Manages the hardware, HW is a 460 | {\color{Orange} shared} resource 461 | \item 462 | Application programmers can easily use HW, Without knowing the HW 463 | details 464 | \end{itemize} 465 | \item Common operating systems 466 | \begin{itemize} 467 | \item Windows XP/Vista/8/10, Linux, Unix, \ldots 468 | \end{itemize} 469 | \end{itemize} 470 | \end{frame} 471 | 472 | \begin{frame} 473 | \frametitle{Computer Organization: Libraries} 474 | \begin{itemize} 475 | \item The libraries provide the most 476 | \textit{\color{Green} common} functionalities 477 | \item In mathematic programs 478 | \begin{itemize} 479 | \item \textit{sin}, \textit{cos}, matrix multiplication/inversion 480 | \end{itemize} 481 | \item In graphical programs 482 | \begin{itemize} 483 | \item Draw a line/cycle, set color, new window 484 | \end{itemize} 485 | \item In multimedia programs 486 | \begin{itemize} 487 | \item Open/close files, jump, \ldots 488 | \end{itemize} 489 | \end{itemize} 490 | \end{frame} 491 | 492 | \begin{frame} 493 | \frametitle{Computer Organization: Applications} 494 | \begin{itemize} 495 | \item An application program 496 | \begin{itemize} 497 | \item Users use them to do some specific things 498 | \item \color{Orange} Without knowing the details of the computer 499 | \end{itemize} 500 | \item Common application programs 501 | \begin{itemize} 502 | \item Word, Internet Explorer, FireFox, Messengers 503 | \end{itemize} 504 | \item Common applications in mathematic: 505 | \begin{itemize} 506 | \item Matlab, Mathematica, Maple, GAMS, AIMMS 507 | \end{itemize} 508 | \end{itemize} 509 | \end{frame} 510 | 511 | \begin{frame} 512 | \frametitle{Programming Execution Phases} 513 | \begin{enumerate} 514 | \item Program is loaded from secondary storage to main memory by OS 515 | \item OS gives the control to the program 516 | \item Instructions run 517 | \item 518 | Required inputs are got from input device \& saved in main memory \& 519 | used by CPU 520 | \item Result is saved in main/secondary memory or sent to output devices 521 | \end{enumerate} 522 | \end{frame} 523 | 524 | \begin{frame} 525 | \frametitle{Programming Execution Phases} 526 | \begin{figure} 527 | \includegraphics[width=.75\textwidth]{./img/cycle.png} 528 | \end{figure} 529 | \end{frame} 530 | 531 | \begin{frame} 532 | \frametitle{Programming Execution Phases} 533 | \begin{itemize} 534 | \item Basic steps in running instructions: 535 | \begin{itemize} 536 | \item 537 | Read instruction from main memory: \textbf{\color{Green} fetch} 538 | \item \textbf{\color{Orange} Decode} the instruction 539 | \item 540 | Get required \textbf{\color{Blue} operands} from main memory 541 | \item \textbf{\color{Red} Run} the instruction 542 | \item Save the \textbf{\color{Cyan} result} 543 | \end{itemize} 544 | \end{itemize} 545 | \end{frame} 546 | 547 | \begin{frame} 548 | \frametitle{Von Neumann architecture} 549 | \begin{itemize} 550 | \item also known as the von Neumann model or Princeton architecture 551 | \item 552 | Keeping both program instructions and data in read-write, random-access 553 | memory (RAM). 554 | \end{itemize} 555 | \end{frame} 556 | 557 | \begin{frame} 558 |

How to be general purpose machine?

559 | \begin{itemize} 560 | \item Hardware is simple \& general purpose 561 | \item Complex tasks (e.g.\ average, sort, \ldots) are programmed by software 562 | \item Software is translated to the basic instructions 563 | \item 564 | This is the way that we 565 | {\color{Orange} program} computers 566 | \end{itemize} 567 | \end{frame} 568 | 569 | \section{Algorithms \& Programming} 570 | 571 | \begin{frame} 572 | \frametitle{Algorithms} 573 | \begin{itemize} 574 | \item Hardware do the basic operations 575 | \item We want to solve a real problem by computers 576 | \item We need a solution that 577 | \begin{itemize} 578 | \item Specifies how the real (complex) problem should be solved 579 | {\color{Orange} step-by-step} using the basic operations 580 | \end{itemize} 581 | \item The solution is the {\color{Green} ``Algorithm''} of the 582 | problem 583 | \end{itemize} 584 | \end{frame} 585 | 586 | \begin{frame} 587 | \frametitle{Algorithms (cont’d)} 588 | \begin{itemize} 589 | \item Common Sense (in computer science): 590 | \begin{enumerate} 591 | \item The way to do some things 592 | \item An abstract way to solve a problem 593 | \end{enumerate} 594 | \item Formal Definition: 595 | \begin{quote} 596 | An algorithm is a \textbf{\color{GreenYellow} finite list} of 597 | \textbf{\color{GreenYellow} well-defined} instructions for accomplishing 598 | some task that, given an \textbf{\color{GreenYellow} initial state}, will 599 | \textbf{\color{GreenYellow} proceed} through a welldefined series of 600 | successive states, possibly eventually 601 | \textbf{\color{GreenYellow} terminating} in an end-state 602 | \end{quote} 603 | \end{itemize} 604 | \end{frame} 605 | 606 | \begin{frame} 607 | \frametitle{Algorithms: Examples} 608 | \begin{itemize} 609 | \item Finding Common Divisor 610 | \item Finding 2 largest element in a set 611 | \item Finding shortest path in a graph 612 | \item Searching in a sorted array 613 | \item Sorting a set 614 | \item Combining 2 sorted set in a sorted set 615 | \item Solving an equation 616 | \item Compression algorithms 617 | \item Cryptography algorithms 618 | \item \ldots 619 | \end{itemize} 620 | \end{frame} 621 | 622 | \begin{frame} 623 | \frametitle{Algorithms: Description} 624 | \begin{itemize} 625 | \item Algorithms are the problem solving steps in our mind!!! 626 | \item How can we document it (don’t forget it)? 627 | \item How can we explain/teach it to others peoples? 628 | \item How can we explain it to computers? 629 | \item We need some methods to describe algorithms! 630 | \begin{itemize} 631 | \item Flow chart 632 | \item Pseudo-codes 633 | \item Codes/Programs 634 | \end{itemize} 635 | \end{itemize} 636 | \end{frame} 637 | 638 | \begin{frame} 639 | \frametitle{Algorithms: Description (cont’d)} 640 | \begin{itemize} 641 | \item Flowcharts: 642 | \begin{figure} 643 | \includegraphics[width=.5\textwidth]{./img/flowchart.png} 644 | \end{figure} 645 | \end{itemize} 646 | \end{frame} 647 | 648 | \begin{frame} 649 | \frametitle{Algorithms: Description (cont’d)} 650 | \begin{itemize} 651 | \item Pseudo-codes: 652 | \item A sequence of English and mathematical statements 653 | \end{itemize} 654 | \begin{algorithm}[H] 655 | \KwData{$n \geq 0$} 656 | \KwResult{$\sum_{i=1}^{n}=i^{2}$} 657 | $sum \gets 0$\; 658 | $i \gets 1$\; 659 | \While{$i \leq n$}{% 660 | $sq \gets i * i$\; 661 | $sum \gets sum + sq$\; 662 | $i \gets i + 1$\; 663 | } 664 | \end{algorithm} 665 | \end{frame} 666 | 667 | \begin{frame} 668 | \frametitle{Algorithms: Description (cont’d)} 669 | \begin{itemize} 670 | \item Flowcharts and Pseudo-code are for humans not for computer 671 | \begin{itemize} 672 | \item Computer \textit{\color{Orange} cannot} run them 673 | \end{itemize} 674 | \item What can computer run? 675 | \begin{itemize} 676 | \item Instructions in main memory 677 | \item 678 | The instructions are in 679 | \textit{\color{Cyan} ``011100001\ldots''} format 680 | \item 681 | To use computers \textmd{We should describe your algorithm in “01” format} 682 | \end{itemize} 683 | \end{itemize} 684 | \end{frame} 685 | 686 | \begin{frame} 687 | \frametitle{Algorithms: Description (cont’d)} 688 | \begin{figure} 689 | \includegraphics[width=.35\textwidth]{./img/assembly.jpg} 690 | \end{figure} 691 | \end{frame} 692 | 693 | \begin{frame} 694 | \frametitle{Programming Language} 695 | \begin{itemize} 696 | \item 697 | Programming languages are the tools to describe your algorithms for 698 | computers 699 | \begin{itemize} 700 | \item Software is developed by programming languages 701 | \end{itemize} 702 | \item New languages which is understandable by computers 703 | \item Human languages are not used. Why? 704 | \item When algorithm is described with a programming language 705 | \begin{itemize} 706 | \item 707 | It cannot be run on computer directly if the languages is not 011001001 708 | \item 709 | There are some other programs that translate the programming language to 710 | ``010\ldots'' 711 | \item The output ``0101\ldots'' can run on computers 712 | \end{itemize} 713 | \end{itemize} 714 | \end{frame} 715 | 716 | \begin{frame} 717 | \frametitle{Programming Language: Machine Level} 718 | \begin{itemize} 719 | \item Computer’s native language 720 | \item What is saved in the main memory 721 | \item 722 | The processor architecture specifies the format of 01s, machine depended 723 | \item Example 724 | \begin{itemize} 725 | \item Add two numbers: 00100111 1010 0101 726 | \end{itemize} 727 | \item Completely incomprehensible to (most) people 728 | \end{itemize} 729 | \end{frame} 730 | 731 | \begin{frame} 732 | \frametitle{Programming Language: Assembly} 733 | \begin{itemize} 734 | \item Programming based on mnemonics 735 | \item 736 | There are {\color{Orange} one-to-one mapping} between 737 | machine language and assembly mnemonics 738 | \end{itemize} 739 | \end{frame} 740 | \begin{frame}[fragile] 741 | \frametitle{Programming Language: Assembly (cont'd)} 742 | \scriptsize 743 | \begin{minted}[bgcolor=Black]{gas} 744 | .file "main.c" 745 | .text 746 | .globl main 747 | .type main, @function 748 | main: 749 | .LFB0: 750 | .cfi_startproc 751 | pushq %rbp 752 | .cfi_def_cfa_offset 16 753 | .cfi_offset 6, -16 754 | movq %rsp, %rbp 755 | .cfi_def_cfa_register 6 756 | movl $12, -4(%rbp) 757 | movl $0, %eax 758 | popq %rbp 759 | .cfi_def_cfa 7, 8 760 | ret 761 | .cfi_endproc 762 | .LFE0: 763 | .size main, .-main 764 | .ident "GCC: (GNU) 11.1.0" 765 | .section .note.GNU-stack,"",@progbits 766 | \end{minted} 767 | \end{frame} 768 | 769 | \begin{frame}[fragile] 770 | \frametitle{Programming Language: High Level} 771 | \begin{itemize} 772 | \item Easy for programming, English-like keywords 773 | \item 774 | There isn’t one-to-one relation between high level statements and machine 775 | level statements 776 | \item Example: C, C++, Pascal, Java, PHP, Python, Go, \ldots 777 | \end{itemize} 778 | \begin{minted}[bgcolor=Black]{c} 779 | int main(void) { 780 | int a = 10 + 2; 781 | } 782 | \end{minted} 783 | \end{frame} 784 | 785 | \begin{frame} 786 | \frametitle{Translation of High Level Languages} 787 | \begin{itemize} 788 | \item Two types of translators 789 | \begin{itemize} 790 | \item Interpreter 791 | \item Compiler 792 | \end{itemize} 793 | \item Interpreter 794 | \begin{itemize} 795 | \item Checks and runs program lines one-by-one 796 | \item Easy, slow, and we need the interpreter 797 | \end{itemize} 798 | \item Compiler 799 | \begin{itemize} 800 | \item Check all lines, creates executable output file 801 | \item Fast and Stand alone program 802 | \end{itemize} 803 | \end{itemize} 804 | \end{frame} 805 | 806 | \begin{frame} 807 | \frametitle{Compiler} 808 | \begin{itemize} 809 | \item 810 | A {\color{Orange} set} of computer programs do the 811 | {\color{Green} Compilation} 812 | \item 813 | \textbf{\color{Orange} Preprocessor}: Prepare file for compiler 814 | \item \textbf{\color{Orange} Compiler}: Create assembly code 815 | \item 816 | \textbf{\color{Green} Assembler}: Convert assembly code to binary 817 | code 818 | \item 819 | \textbf{\color{Green} Linker}: Collect all required binary files 820 | (from libraries) into a single loadable file 821 | \item Each language has its own compiler 822 | \end{itemize} 823 | 824 | \begin{block}{} 825 | Usually compiler do all above steps, you just compile the file and get a 826 | executable file 827 | \end{block} 828 | \end{frame} 829 | 830 | \begin{frame} 831 | \frametitle{Compiler} 832 | \begin{figure} 833 | \includegraphics[width=.75\textwidth]{./img/build-flow.png} 834 | \end{figure} 835 | \end{frame} 836 | 837 | \section{Solving problems} 838 | 839 | \begin{frame} 840 | \frametitle{Solving Problems} 841 | \begin{itemize} 842 | \item How to solve problems using computers 843 | \begin{itemize} 844 | \item Develop a {\color{Orange} program} for it 845 | \end{itemize} 846 | \item Steps 847 | \begin{enumerate} 848 | \item Analysis: Input, output 849 | \item Algorithm Design 850 | \item Coding 851 | \item Compile (Program) 852 | \item Execution (Test) 853 | \item Documentation 854 | \end{enumerate} 855 | \end{itemize} 856 | \end{frame} 857 | 858 | \begin{frame} 859 | \frametitle{Solving Problems: Analysis} 860 | 861 | \begin{itemize} 862 | \item Problem solving process consists of: Input, Algorithm, Output 863 | \item Determine what information is available as the input to your algorithm 864 | \item Determine what information is desired as the output from your algorithm 865 | \item 866 | What needs to be done on the input to produce the output? 867 | \textbf{\color{Orange} Algorithm} 868 | \end{itemize} 869 | \end{frame} 870 | 871 | \begin{frame} 872 | \frametitle{Solving Problems: Algorithm} 873 | \begin{itemize} 874 | \item 875 | Determine a series of steps that transforms the input data into the output 876 | results 877 | \item 878 | Find all the \textit{\color{RubineRed} special cases} that the must be 879 | handled 880 | \item 881 | If necessary modify or redesign your series of steps so that all special 882 | cases are handled 883 | \item Verify your algorithm 884 | \end{itemize} 885 | \end{frame} 886 | 887 | \begin{frame} 888 | \frametitle{Solving Problems: Coding} 889 | \begin{itemize} 890 | \item Describe your algorithm by a programming language 891 | \item 892 | You must code exactly in the programming language 893 | \textit{\color{Orange} syntax} 894 | \item Compiler itself is a program it isn’t a human 895 | \begin{itemize} 896 | \item It is not intelligent 897 | \item It just does the steps of the compiling algorithm 898 | \item It does not understand what do you mean!!! 899 | \end{itemize} 900 | \end{itemize} 901 | \end{frame} 902 | 903 | \begin{frame} 904 | \frametitle{Solving Program: Execution} 905 | \begin{itemize} 906 | \item Compiler generated the executable file 907 | \item Run the executable code 908 | \begin{itemize} 909 | \item First try to use simple 910 | \item Then try larger and complex inputs 911 | \end{itemize} 912 | \end{itemize} 913 | \end{frame} 914 | 915 | \begin{frame} 916 | \frametitle{Solving Program} 917 | \begin{figure} 918 | \includegraphics[height=.75\textheight]{./img/code-progress.png} 919 | \end{figure} 920 | \end{frame} 921 | 922 | \begin{frame} 923 | \frametitle{Errors in Solving Problems} 924 | \begin{itemize} 925 | \item Compile / Syntax error: Compiler does not recognize your code 926 | \item Link error: Linker cannot find the required libraries 927 | \item Runtime error: Program does not run correctly 928 | \begin{itemize} 929 | \item Example: Division by zero 930 | \end{itemize} 931 | \item Logical Error: Program does not produce the expected result 932 | \begin{itemize} 933 | \item It is called \textit{\color{Red} bug} 934 | \item No one (compiler, assembler) except debugger can help you 935 | \end{itemize} 936 | \end{itemize} 937 | \end{frame} 938 | 939 | \begin{frame} 940 | \frametitle{Errors in Solving Problems} 941 | \begin{itemize} 942 | \item Why error? 943 | \begin{itemize} 944 | \item You do not understand and analysis the problem correctly 945 | \item You do not develop a right algorithm for the problem 946 | \item You have mistakes in your coding 947 | \end{itemize} 948 | \end{itemize} 949 | \end{frame} 950 | 951 | \begin{frame} 952 | \frametitle{Debugging} 953 | \begin{itemize} 954 | \item The process of resolving the errors 955 | \begin{itemize} 956 | \item Example: A program to divide two numbers 957 | \end{itemize} 958 | 959 | \item Compile/Syntax error 960 | \begin{itemize} 961 | \item Compiler tells where it is, check syntax 962 | \end{itemize} 963 | 964 | \item Link error 965 | \begin{itemize} 966 | \item Compiler tells what it is, check syntax \& libraries 967 | \end{itemize} 968 | 969 | \item Run time error 970 | \begin{itemize} 971 | \item 972 | Try to find it, use debugger to run step-by-step, print debug messages 973 | \item Check syntax \& semantic of the line 974 | \end{itemize} 975 | \end{itemize} 976 | \end{frame} 977 | 978 | \begin{frame} 979 | \frametitle{Debugging} 980 | \begin{itemize} 981 | \item Logical error 982 | \begin{itemize} 983 | \item 984 | Try to find it, use debugger to run step-by-step, print debug messages 985 | \item Check syntax \& semantic of program 986 | \item Revise the algorithm 987 | \end{itemize} 988 | \end{itemize} 989 | \end{frame} 990 | 991 | \begin{frame} 992 | \frametitle{Desired Features of Programs} 993 | \begin{itemize} 994 | \item \textbf{Integrity} 995 | Correctly solve the problem 996 | \item \textbf{Clarity} 997 | Easy to read 998 | \item \textbf{Simplicity} 999 | Easy to understand 1000 | \item \textbf{Efficiency} 1001 | Speed and memory 1002 | \item \textbf{Modularity} 1003 | Break down of a large task 1004 | \item \textbf{Generality} 1005 | Tunable by input as much as possible 1006 | \end{itemize} 1007 | \end{frame} 1008 | 1009 | \begin{frame} 1010 | \frametitle{Summary} 1011 | \begin{itemize} 1012 | \item Computer organization 1013 | \begin{itemize} 1014 | \item Hardware and Software 1015 | \end{itemize} 1016 | \pause% 1017 | \item Algorithm \& Program 1018 | \begin{itemize} 1019 | \item What is the difference between them 1020 | \end{itemize} 1021 | \pause% 1022 | \item How to solve a problem using computer 1023 | \begin{itemize} 1024 | \item Steps 1025 | \end{itemize} 1026 | \pause% 1027 | \item Errors in problem solving 1028 | \item What is the next: Design algorithm 1029 | \end{itemize} 1030 | \end{frame} 1031 | 1032 | \begin{frame} 1033 | \frametitle{Legends} 1034 | \begin{figure} 1035 | \includegraphics[height=.75\textheight]{./img/torvalds.png} 1036 | \end{figure} 1037 | \pause% 1038 | \centering 1039 | \color{Violet} Linus Torvalds 1040 | \end{frame} 1041 | 1042 | \begin{frame} 1043 | \frametitle{Legends} 1044 | \begin{itemize} 1045 | \item Finnish-American software engineer who is the creator and, historically, the main developer of the Linux kernel, 1046 | used by Linux distributions and other operating systems such as Android. 1047 | \item He also created the distributed version control system Git 1048 | \end{itemize} 1049 | \end{frame} 1050 | 1051 | \end{document} 1052 | -------------------------------------------------------------------------------- /lecture-10/img/dijkstra.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-10/img/dijkstra.jpg -------------------------------------------------------------------------------- /lecture-10/img/null-empty-string.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-10/img/null-empty-string.png -------------------------------------------------------------------------------- /lecture-10/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-11/img/ll-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-11/img/ll-1.png -------------------------------------------------------------------------------- /lecture-11/img/ll-2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-11/img/ll-2.png -------------------------------------------------------------------------------- /lecture-11/img/rob.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-11/img/rob.jpg -------------------------------------------------------------------------------- /lecture-11/img/union.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-11/img/union.png -------------------------------------------------------------------------------- /lecture-11/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-11/src/union-size.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | union test1 { 4 | int x; 5 | int y; 6 | } Test1; 7 | 8 | union test2 { 9 | int x; 10 | char y; 11 | } Test2; 12 | 13 | union test3 { 14 | int arr[10]; 15 | char y; 16 | } Test3; 17 | 18 | int main() { 19 | printf("sizeof(test1) = %lu, " 20 | "sizeof(test2) = %lu, " 21 | "sizeof(test3) = %lu\n", 22 | sizeof(Test1), 23 | sizeof(Test2), sizeof(Test3)); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /lecture-12/img/yoda.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-12/img/yoda.jpg -------------------------------------------------------------------------------- /lecture-12/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-13/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-13/main.tex: -------------------------------------------------------------------------------- 1 | \documentclass{../c-lecture} 2 | 3 | \subtitle{Miscellaneous} 4 | 5 | \begin{document} 6 | 7 | \begin{frame} 8 | \titlepage{} 9 | \end{frame} 10 | 11 | \begin{frame} 12 | \frametitle{File postfix} 13 | \begin{itemize} 14 | \item Most compilers consider the source code file postfix 15 | \begin{itemize} 16 | \item .c \textrightarrow C code 17 | \item .cc .cpp \textrightarrow C++ code 18 | \end{itemize} 19 | \end{itemize} 20 | \end{frame} 21 | 22 | \begin{frame}[fragile] 23 | \frametitle{A program in multiple file} 24 | \begin{itemize} 25 | \item We can create our {\color{Yellow} .h} files 26 | \item 27 | These files contains \textit{\color{YellowOrange} structs}, 28 | \textit{\color{LimeGreen} functions declaration}, etc. 29 | \item func.c 30 | \begin{minted}[bgcolor=Black]{c} 31 | #include 32 | 33 | void f(int x) { 34 | printf("%d", x); 35 | } 36 | \end{minted} 37 | \item func.h 38 | \begin{minted}[bgcolor=Black]{c} 39 | #ifndef FUNC_H 40 | #define FUNC_H 41 | void f(int); 42 | #endif 43 | \end{minted} 44 | \end{itemize} 45 | \end{frame} 46 | 47 | \begin{frame}[fragile] 48 | \begin{itemize} 49 | \item Then includes header to use 50 | \item main.c 51 | \begin{minted}[bgcolor=Black]{c} 52 | #include "func.h" 53 | 54 | int main(void) { 55 | f(20); 56 | } 57 | \end{minted} 58 | \end{itemize} 59 | \end{frame} 60 | 61 | \begin{frame}[fragile] 62 | \frametitle{Preprocessor Command} 63 | \begin{itemize} 64 | \item 65 | We can use preprocessor commands to control how our code is compiled and 66 | etc. 67 | \begin{itemize} 68 | \item Conditional compilation 69 | \end{itemize} 70 | \item Main preprocessor commands 71 | \begin{minted}[bgcolor=Black]{c} 72 | #define XYZ // define XYZ as a preprocessor definition (value is not important) 73 | #ifdef XYZ // is true if XYZ is defined 74 | #ifndef XYZ // is true if XYZ is not defined 75 | #if XYZ // is true if XYZ != 0 76 | #endif // End of a if block 77 | \end{minted} 78 | \end{itemize} 79 | \end{frame} 80 | 81 | \begin{frame}[fragile] 82 | \begin{minted}[bgcolor=Black]{c} 83 | #include 84 | 85 | #define ABC 86 | #define XYZ 1 87 | int main() { 88 | #ifdef ABC 89 | printf("ABC is defined \n"); 90 | #endif 91 | printf ("I am here\n"); 92 | #if XYZ 93 | printf("XYZ is defined and is not 0\n"); 94 | #endif 95 | } 96 | \end{minted} 97 | \end{frame} 98 | 99 | \begin{frame}[fragile] 100 | \frametitle{Preprocessor Command} 101 | \begin{itemize} 102 | \item Generate code before compilation 103 | \begin{minted}[bgcolor=Black]{c} 104 | #include 105 | #define A 10 106 | #define P(x) int x = 10; 107 | \end{minted} 108 | \begin{minted}[bgcolor=Black]{c} 109 | int main() { 110 | int a = A; 111 | P(b); 112 | printf("%d\n", a); 113 | printf("%d\n", b); 114 | } 115 | \end{minted} 116 | \end{itemize} 117 | \end{frame} 118 | 119 | \begin{frame}[fragile] 120 | \begin{itemize} 121 | \item Here we have the generated code 122 | \item Pay attention to double semi-colons. 123 | \begin{minted}[bgcolor=Black]{c} 124 | int main() { 125 | int a = 10; 126 | int b = 10;; 127 | printf("%d\n", a); 128 | printf("%d\n", b); 129 | } 130 | \end{minted} 131 | \end{itemize} 132 | \end{frame} 133 | 134 | \end{document} 135 | -------------------------------------------------------------------------------- /lecture-14/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-14/main.tex: -------------------------------------------------------------------------------- 1 | \documentclass{../c-lecture} 2 | 3 | \subtitle{Buckle Up} 4 | 5 | \usepackage{algorithm2e} 6 | 7 | \begin{document} 8 | 9 | \begin{frame} 10 | \titlepage{} 11 | \end{frame} 12 | \begin{frame} 13 | \frametitle{Outline} 14 | \tableofcontents{} 15 | \end{frame} 16 | 17 | \begin{frame} 18 | \frametitle{} 19 | \begin{block}{} 20 | We bind type modifiers and qualifiers to the left. 21 | \end{block} 22 | \end{frame} 23 | 24 | \begin{frame} 25 | \frametitle{} 26 | \begin{block}{} 27 | We don't use continued declarations. 28 | \end{block} 29 | \end{frame} 30 | 31 | \begin{frame} 32 | \frametitle{} 33 | \begin{block}{} 34 | We use array notation for pointer parameters. 35 | \end{block} 36 | \end{frame} 37 | 38 | \begin{frame} 39 | \frametitle{} 40 | \begin{block}{} 41 | We use function notation for function pointer parameters. 42 | \end{block} 43 | \end{frame} 44 | 45 | \begin{frame} 46 | \frametitle{} 47 | \begin{block}{} 48 | We define variables as close to their first use as possible. 49 | \end{block} 50 | \end{frame} 51 | 52 | \begin{frame} 53 | \frametitle{} 54 | \begin{block}{} 55 | We use prefix notation for code blocks. 56 | \end{block} 57 | \end{frame} 58 | 59 | \end{document} 60 | -------------------------------------------------------------------------------- /lecture-2/img/dennis.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-2/img/dennis.jpg -------------------------------------------------------------------------------- /lecture-2/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-2/main.tex: -------------------------------------------------------------------------------- 1 | \documentclass{../c-lecture} 2 | 3 | \usepackage{algorithm2e} 4 | 5 | \subtitle{Algorithm Design} 6 | 7 | \begin{document} 8 | 9 | \begin{frame} 10 | \titlepage{} 11 | \end{frame} 12 | 13 | \begin{frame} 14 | \frametitle{What We Will Learn} 15 | \begin{itemize} 16 | \item Sample algorithms to practice problem solving steps 17 | \item Input \& Output analysis 18 | \item Algorithm design 19 | \begin{itemize} 20 | \item Pseudo-code 21 | \end{itemize} 22 | \end{itemize} 23 | \end{frame} 24 | 25 | \begin{frame} 26 | \frametitle{Average} 27 | \begin{algorithm}[H] 28 | \KwData{$x_1, x_2, x_3$} 29 | \KwResult{$avg(x_1, x_2, x_3)$} 30 | $sum \gets x_1 + x_2 + x_3$\; 31 | $avg \gets sum / 3$\; 32 | print ``average = '' $avg$ \; 33 | \end{algorithm} 34 | \end{frame} 35 | 36 | \begin{frame} 37 | \frametitle{Odd-Even-1} 38 | \begin{algorithm}[H] 39 | \KwData{$n \in \mathbb{Z}$} 40 | \KwResult{$n$ is even or odd} 41 | $r \gets n \% 2$\; 42 | \eIf{$r == 0$}{% 43 | print $n$ ``is even''\; 44 | }{% 45 | print $n$ ``is odd''\; 46 | } 47 | \end{algorithm} 48 | \end{frame} 49 | 50 | \begin{frame} 51 | \frametitle{Odd-Even-2} 52 | \begin{algorithm}[H] 53 | \KwData{$n \in \mathbb{Z}$} 54 | \KwResult{$n$ is even or odd} 55 | $m \gets n$\; 56 | \If{n < 0}{% 57 | $n \gets -1 * n$\; 58 | } 59 | \While{$n > 0$}{% 60 | $n \gets n - 2$\; 61 | } 62 | \eIf{$n == 0$}{% 63 | print $m$ ``is even''\; 64 | }{% 65 | print $m$ ``is odd''\; 66 | } 67 | \end{algorithm} 68 | \end{frame} 69 | 70 | \begin{frame} 71 | \frametitle{Odd-Even-3} 72 | \begin{algorithm}[H] 73 | \KwData{$n \in \mathbb{Z}$} 74 | \KwResult{$n$ is even or odd} 75 | \SetKw{Or}{or} 76 | \SetKwFunction{Sign}{sign} 77 | $m \gets n$\; 78 | \While{$n > 0$ \Or $n < -1$}{% 79 | \tcp{$sign(0) = 0, sign(n > 0) = 1, sign(n < 0) = -1$} 80 | $n \gets n - \Sign(n) * 2$\; 81 | } 82 | \eIf{$n == 0$}{% 83 | print $n$ ``is even''\; 84 | }{% 85 | print $n$ ``is odd''\; 86 | } 87 | \end{algorithm} 88 | \end{frame} 89 | 90 | \begin{frame} 91 | \frametitle{Count Odd-Even} 92 | \begin{block}{} 93 | The algorithm read array of numbers that are ending with 0 then count even 94 | and odd numbers. 95 | \end{block} 96 | \end{frame} 97 | 98 | \begin{frame} 99 | \frametitle{Count Odd-Even} 100 | \begin{algorithm}[H] 101 | \KwData{$\forall n \in \mathbb{Z}$} 102 | \KwResult{number of even and odd numbers} 103 | $even\_cnt \gets 0$\; 104 | $odd\_cnt \gets 0$\; 105 | read $n$\; 106 | \While{$n \neq 0$}{% 107 | $r \gets n \% 2$\; 108 | \eIf{$r == 0$}{% 109 | $even\_cnt \gets even\_cnt + 1$\; 110 | }{% 111 | $odd\_cnt \gets odd\_cnt + 1$\; 112 | } 113 | read $n$\; 114 | } 115 | print ``Odd = '' $odd\_cnt$ ``Even = '' $even\_cnt$\; 116 | \end{algorithm} 117 | \end{frame} 118 | 119 | \begin{frame} 120 | \frametitle{Digit-Sum} 121 | \begin{algorithm}[H] 122 | \KwData{$n \in \mathbb{Z} \geq 0$} 123 | \KwResult{sum of digits} 124 | $sum \gets 0$\; 125 | $m \gets n$\; 126 | \While{$n \neq 0$}{% 127 | $d \gets n \% 10$\; 128 | $sum \gets sum + d$\; 129 | $n \gets n - d$\; 130 | $n \gets n / 10$\; 131 | } 132 | print ``sum of digits of'' $m$ `` = '' $sum$\; 133 | \end{algorithm} 134 | \end{frame} 135 | 136 | \begin{frame} 137 | \frametitle{Base-8} 138 | \begin{algorithm}[H] 139 | \KwData{$n \in \mathbb{Z} \geq 0$} 140 | \KwResult{$n$ in base-8} 141 | $i \gets 0$\; 142 | \While{$n \neq 0$}{% 143 | $x[i] \gets n \% 8$\; 144 | $n \gets \lfloor n / 8 \rfloor$\; 145 | $i \gets i + 1$\; 146 | } 147 | \While{$i \geq 0$}{% 148 | $i \gets i - 1$\; 149 | print $x[i]$ 150 | } 151 | \end{algorithm} 152 | \end{frame} 153 | 154 | \begin{frame} 155 | \frametitle{Factorial-1} 156 | \begin{algorithm}[H] 157 | \KwData{$n \in \mathbb{Z} \geq 0$} 158 | \KwResult{$ result = n! $} 159 | $i \gets 1$\; 160 | $result \gets 1$\; 161 | \While{$i \leq n$}{% 162 | $result \gets i * result$\; 163 | $i \gets i + 1$\; 164 | } 165 | \end{algorithm} 166 | \end{frame} 167 | 168 | \begin{frame} 169 | \frametitle{Factorial-2} 170 | \begin{algorithm}[H] 171 | \KwData{$n \in \mathbb{Z} \geq 0$} 172 | \KwResult{$ result = n! $} 173 | $result \gets 1$\; 174 | \While{$n > 0$}{% 175 | $result \gets n * result$\; 176 | $n \gets n - 1$\; 177 | } 178 | \end{algorithm} 179 | \end{frame} 180 | 181 | \begin{frame} 182 | \frametitle{$factorial\_recursive(n)$} 183 | \begin{algorithm}[H] 184 | \KwData{$n \in \mathbb{Z} \geq 0$} 185 | \KwResult{$ factorial\_recursive(n) = n! $} 186 | \eIf{n == 1}{% 187 | return 1\; 188 | }{% 189 | return $n * factorial\_recursive(n - 1)$\; 190 | } 191 | \end{algorithm} 192 | \end{frame} 193 | 194 | \begin{frame} 195 | \frametitle{$sort(X, start, end)$} 196 | \begin{algorithm}[H] 197 | \KwData{$X = \{x | x \in \mathbb{Z}\}$} 198 | \KwResult{sorted $X$} 199 | \While{$start \neq end$}{% 200 | \tcp{find index of minimum element from $start$ to $end$} 201 | $j \gets find\_\min(X, start, end)$\; 202 | $swap(X, j, start)$\; 203 | $start \gets start + 1$\; 204 | } 205 | \end{algorithm} 206 | \end{frame} 207 | 208 | \begin{frame} 209 | \frametitle{$find\_\min(X, start, end)$} 210 | \begin{algorithm}[H] 211 | \KwData{$X = \{x | x \in \mathbb{Z}\}$} 212 | \KwResult{$index$ = index of minimum element from $X$} 213 | $i \gets start$\; 214 | $index \gets i$\; 215 | \While{$i \leq end$}{% 216 | \If{$X[i] < X[index]$}{% 217 | $index \gets i$\; 218 | } 219 | $i \gets i + 1$\; 220 | } 221 | \end{algorithm} 222 | \end{frame} 223 | 224 | \begin{frame} 225 | \frametitle{$swap(X, j, i)$} 226 | \begin{algorithm}[H] 227 | \KwData{$X = \{x | x \in \mathbb{Z}\}$} 228 | \KwResult{} 229 | $tmp \gets X[j]$\; 230 | $X[j] \gets X[i]$\; 231 | $X[i] \gets temp$\; 232 | \end{algorithm} 233 | \end{frame} 234 | 235 | \begin{frame} 236 | \frametitle{$reverse(A, start, end)$} 237 | \begin{algorithm}[H] 238 | \KwData{$A = \{a | a \in \mathbb{Z}\}$} 239 | \KwResult{A in a reverse order} 240 | \eIf{$start \geq end$}{% 241 | return\; 242 | }{% 243 | $swap(A, start, end)$\; 244 | $reverse(A, start + 1, end - 1)$\; 245 | } 246 | \end{algorithm} 247 | \end{frame} 248 | 249 | \begin{frame} 250 | \frametitle{Summary} 251 | \begin{itemize} 252 | \item There are more than one algorithm for a problem 253 | \begin{itemize} 254 | \item Efficiency, Complexity, Clarity, \ldots 255 | \end{itemize} 256 | \item Algorithm (Programming Language) building blocks 257 | \begin{itemize} 258 | \item Input / Output (Lecture 5) 259 | \item Calculations (Lecture 4) 260 | \item Decision Making (Lecture 6) 261 | \item Repeating (Lecture 7) 262 | \item Modular Programming (Lecture 8) 263 | \item Arrays + Memory Management (Lectures 9 + 10) 264 | \item Others (Files, …) (Lecture 11 + 12) 265 | \end{itemize} 266 | \end{itemize} 267 | \end{frame} 268 | 269 | \begin{frame} 270 | \frametitle{Legends} 271 | \begin{figure} 272 | \includegraphics[height=.75\textheight]{./img/dennis.jpg} 273 | \end{figure} 274 | \pause% 275 | \centering 276 | \color{Violet} Dennis Ritchie 277 | \end{frame} 278 | 279 | \begin{frame} 280 | \frametitle{Legends} 281 | \begin{itemize} 282 | \item September 9, 1941 – October 12, 2011 283 | \item an American computer scientist 284 | \item He created the \textit{\color{Orange} C} programming language and, 285 | with long-time colleague Ken Thompson, the \textit{\color{LimeGreen} Unix} operating system and \textit{\color{RubineRed} B} programming language 286 | \end{itemize} 287 | \end{frame} 288 | 289 | \end{document} 290 | -------------------------------------------------------------------------------- /lecture-3/img/van.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-3/img/van.jpg -------------------------------------------------------------------------------- /lecture-3/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-3/main.tex: -------------------------------------------------------------------------------- 1 | \documentclass{../c-lecture} 2 | 3 | \subtitle{C Programming Basics} 4 | 5 | \begin{document} 6 | 7 | \begin{frame} 8 | \titlepage{} 9 | \end{frame} 10 | \begin{frame} 11 | \frametitle{Outline} 12 | \tableofcontents{} 13 | \end{frame} 14 | 15 | \section{What is the C} 16 | 17 | \begin{frame} 18 | \frametitle{The C Language} 19 | \begin{itemize} 20 | \item {\color{YellowOrange} C} is a 21 | {\color{YellowOrange} general-purpose} programming language 22 | \item {\color{LimeGreen}C} is developed by 23 | {\color{LimeGreen} Dennis Ritchie} at 24 | {\color{LimeGreen} Bell Laboratories} 25 | \item {\color{Orange} C} is one of the widely used languages 26 | \begin{itemize} 27 | \item Application development 28 | \item System programs, most operating systems are developed in C:\@ Unix, Linux 29 | \item Many other languages are based on it 30 | \end{itemize} 31 | \end{itemize} 32 | \end{frame} 33 | 34 | \begin{frame} 35 | \frametitle{The C Language} 36 | \begin{itemize} 37 | \item A C program completes some specific task by giving orders 38 | \item C is an \textbf{\color{Orange} imperative programming language} 39 | \item C is a \textbf{\color{LimeGreen} compiled programming lanugage} 40 | \end{itemize} 41 | \end{frame} 42 | 43 | \begin{frame} 44 | \frametitle{Programming in C Language} 45 | \begin{itemize} 46 | \item C programming language 47 | \begin{itemize} 48 | \item A set of notations for representing programs 49 | \end{itemize} 50 | \item C standard libraries 51 | \begin{itemize} 52 | \item A set of developed programs (functions) 53 | \end{itemize} 54 | \item C programming environment 55 | \begin{itemize} 56 | \item A set of tools to aid program development 57 | \end{itemize} 58 | \end{itemize} 59 | \end{frame} 60 | 61 | \begin{frame}[fragile] 62 | \frametitle{The First Example} 63 | \begin{itemize} 64 | \item Write a program that prints 65 | \end{itemize} 66 | \begin{minted}[bgcolor=Black]{output} 67 | “Hello the CE juniors :-)” 68 | \end{minted} 69 | \end{frame} 70 | 71 | \begin{frame}[fragile] 72 | \frametitle{The First C Program} 73 | \begin{minted}[bgcolor=Black]{c} 74 | #include 75 | 76 | int main(void){ 77 | printf("Hello the CE juniors :-) \n"); 78 | return 0; 79 | } 80 | \end{minted} 81 | \end{frame} 82 | 83 | \begin{frame}[fragile] 84 | \frametitle{General Rules} 85 | \begin{itemize} 86 | \item C is case sensitive: {\color{LimeGreen} main} is not 87 | {\color{Red} MaIn} 88 | \item A ``;'' is required after each statement 89 | \item Each program should have a 90 | {\color{Orange} main} function 91 | \begin{minted}[bgcolor=Black]{c} 92 | int main(void){... 93 | void main(void){... 94 | main(){... 95 | int main(int argc, char ** argv){... 96 | \end{minted} 97 | \item Program starts running from the main 98 | \item You should follow coding style (beautiful code) 99 | \end{itemize} 100 | \end{frame} 101 | 102 | \begin{frame}[fragile] 103 | \frametitle{Comments} 104 | \begin{itemize} 105 | \item Comments are ignored by the compiler 106 | \item It is perfect place to explain and document your code 107 | \end{itemize} 108 | \begin{minted}[bgcolor=Black]{c} 109 | /* Our first 110 | C program */ 111 | #include 112 | 113 | int main(void) { 114 | // This program prints a simple message 115 | // [the c++style comment] 116 | printf("Hello the CE juniors :-) \n"); 117 | return 0; 118 | } 119 | \end{minted} 120 | \end{frame} 121 | 122 | \begin{frame} 123 | \frametitle{The First C Program} 124 | \begin{itemize} 125 | \item You should 126 | \begin{itemize} 127 | \item Develop the source code of program 128 | \item Compile 129 | \item Run 130 | \item Debug 131 | \end{itemize} 132 | \item All of them can be done in IDE 133 | \begin{itemize} 134 | \item Code::Blocks 135 | \item CLion 136 | \item VS Code 137 | \end{itemize} 138 | \end{itemize} 139 | \end{frame} 140 | 141 | \section{Structure} 142 | 143 | \begin{frame} 144 | \frametitle{Declaration} 145 | \begin{itemize} 146 | \item Identifiers are ``names'' that we give to certain entities in the program. 147 | \item before we may use a particular identifier in a program 148 | \begin{itemize} 149 | \item we have to give the compiler a \textbf{\color{Peach} declaration} that specifies what that identifier is supposed to represent. 150 | \end{itemize} 151 | \item Identifiers may have serveral consistent declarations. 152 | \item Declarations are bound to the scope in which they appear. 153 | \end{itemize} 154 | \end{frame} 155 | 156 | \begin{frame} 157 | \frametitle{Definitions} 158 | \begin{itemize} 159 | \item Declarations specify identifiers, whereas definitions specify objects. 160 | \item An object is defined at the same time it is initialized. 161 | \item Each object or function must have \textbf{\color{Cyan} exactly one definition}. 162 | \end{itemize} 163 | \end{frame} 164 | 165 | \begin{frame} 166 | \frametitle{Statement} 167 | \begin{itemize} 168 | \item Statements are instructions that tell the compiler what to do with identifiers that \textit{\color{Peach} has been declared so far}. 169 | \end{itemize} 170 | \end{frame} 171 | 172 | \section{Variables} 173 | 174 | \begin{frame} 175 | \frametitle{Variables} 176 | \begin{itemize} 177 | \item Solving problems 178 | \begin{itemize} 179 | \item Input data --- Algorithm --- Output data 180 | \end{itemize} 181 | \item What we need 182 | \begin{itemize} 183 | \item Implementing the algorithm 184 | \begin{itemize} 185 | \item Named {\color{Orange} Functions} 186 | \item We will discuss later 187 | \end{itemize} 188 | \item Storing the input/output data 189 | \begin{itemize} 190 | \item {\color{Orange} Variables} 191 | \end{itemize} 192 | \end{itemize} 193 | \end{itemize} 194 | \end{frame} 195 | 196 | \begin{frame} 197 | \frametitle{Variables (cont'd)} 198 | \begin{itemize} 199 | \item Data is stored in the main memory 200 | \item Variables 201 | \begin{itemize} 202 | \item Are the {\color{Orange} name} of locations in the main 203 | memory 204 | \begin{itemize} 205 | \item We use names instead of physical addresses 206 | \end{itemize} 207 | \item Specify the {\color{Green} coding} of the location 208 | \begin{itemize} 209 | \item What do the ``01''s means? 210 | \item What is the {\color{Cyan} type} of data? 211 | \end{itemize} 212 | \end{itemize} 213 | \end{itemize} 214 | \end{frame} 215 | 216 | \begin{frame} 217 | \frametitle{Variables (cont’d)} 218 | \begin{itemize} 219 | \item Variables in the C 220 | \begin{itemize} 221 | \item 222 | \end{itemize} 223 | \item {\color{Orange} } 224 | \begin{itemize} 225 | \item Is optional 226 | \item We will discuss later 227 | \end{itemize} 228 | \item {\color{Green}} 229 | \begin{itemize} 230 | \item Specifies the coding 231 | \end{itemize} 232 | \item {\color{Cyan}} 233 | \begin{itemize} 234 | \item Is the name 235 | \end{itemize} 236 | \end{itemize} 237 | \end{frame} 238 | 239 | \begin{frame} 240 | \frametitle{Types: Integers} 241 | \begin{itemize} 242 | \item Integer numbers 243 | \begin{itemize} 244 | \item Different types, different sizes, different ranges 245 | \end{itemize} 246 | \end{itemize} 247 | \end{frame} 248 | 249 | \begin{frame} 250 | \frametitle{Types: Integers} 251 | \begin{table} 252 | \begin{tabular}{cccc} 253 | \toprule 254 | 255 | Type & 256 | Size & 257 | Unsigned & 258 | Signed \\ 259 | 260 | \midrule 261 | 262 | short & 263 | 16 bits & 264 | $[0, 2^{16})$ & 265 | $[-2^{15}, 2^{15})$ \\ 266 | 267 | \midrule 268 | 269 | int & 270 | 32 bits & 271 | $[0, 2^{32})$ & 272 | $[-2^{31}, 2^{31})$ \\ 273 | 274 | \midrule 275 | 276 | long --- long int & 277 | 32/64 bits & 278 | $[0, 2^{32/64})$ & 279 | $[-2^{31/63}, 2^{31/63})$ \\ 280 | 281 | \midrule 282 | 283 | long long --- long long int & 284 | 64 bits & 285 | $[0, 2^{64})$ & 286 | $[-2^{63}, 2^{63})$ \\ 287 | 288 | \bottomrule 289 | \end{tabular} 290 | \end{table} 291 | \end{frame} 292 | 293 | \begin{frame} 294 | \frametitle{Types: Float \& Double} 295 | \begin{itemize} 296 | \item Floating point number 297 | \end{itemize} 298 | \begin{table} 299 | \begin{tabular}{cc} 300 | \toprule 301 | 302 | float & 303 | 32 bits \\ 304 | 305 | \midrule 306 | 307 | double & 308 | 64 bits \\ 309 | 310 | \midrule 311 | 312 | long double & 313 | 96 bits \\ 314 | 315 | \bottomrule 316 | \end{tabular} 317 | \end{table} 318 | \begin{itemize} 319 | \item Limited precision 320 | \begin{itemize} 321 | \item float: 8 digits precision 322 | \item double: 16 digits precision 323 | \end{itemize} 324 | \end{itemize} 325 | \end{frame} 326 | 327 | \begin{frame} 328 | \frametitle{Overflow \& Underflow} 329 | \begin{itemize} 330 | \item All types have limited number of bits 331 | \begin{itemize} 332 | \item Limited range of number are supported 333 | \item Limited precision 334 | \end{itemize} 335 | \item Overflow 336 | \begin{itemize} 337 | \item Assign a very big number to a variable that is larger than the limit of 338 | the variable 339 | \end{itemize} 340 | \item Underflow 341 | \begin{itemize} 342 | \item Assign a very small number to a variable that is smaller than the limit 343 | of the variable 344 | \end{itemize} 345 | \end{itemize} 346 | \end{frame} 347 | 348 | \begin{frame} 349 | \frametitle{Types: Char} 350 | \begin{itemize} 351 | \item Character 352 | \begin{itemize} 353 | \item Type: char 354 | \end{itemize} 355 | \item Single letters of the alphabet, punctuation symbols 356 | \item Should be single quotation 357 | \end{itemize} 358 | \end{frame} 359 | 360 | \begin{frame} 361 | \frametitle{Variables: Identifier} 362 | \begin{itemize} 363 | \item The name of variables: {\color{Orange} identifier} 364 | \item Identifier is string ({\color{Green} single word}) 365 | \begin{itemize} 366 | \item Alphabet 367 | \item Numbers 368 | \item \_ 369 | \end{itemize} 370 | \item But 371 | \begin{itemize} 372 | \item Can {\color{Cyan} not} start with digits 373 | \item Can {\color{Cyan} not} be the key-words (reserved 374 | words) 375 | \item Can {\color{Cyan} not} be duplicated 376 | \item Should {\color{Cyan} not} be library function names: \mintinline{c}|printf| 377 | \end{itemize} 378 | \end{itemize} 379 | \end{frame} 380 | 381 | \begin{frame} 382 | \frametitle{Variables: Identifier} 383 | \begin{itemize} 384 | \item Use readable identifiers 385 | \begin{itemize} 386 | \item Do not use memorystartaddress 387 | \item Use memory\_start\_address 388 | \item Do not use xyz, abc, z, x, t 389 | \item Use counter, sum, average, result, parameter, \ldots 390 | \item Do not be lazy 391 | \item Use meaningful names 392 | \end{itemize} 393 | \end{itemize} 394 | \end{frame} 395 | 396 | \begin{frame} 397 | \frametitle{Variables: Identifier} 398 | \begin{itemize} 399 | \item Valid identifiers:\@ student --- grade --- sum --- all\_students --- average\_grade\_1 400 | \item Invalid identifiers:\@ if --- 32\_test --- wrong* --- \$sds\$ 401 | \end{itemize} 402 | \end{frame} 403 | 404 | \begin{frame}[fragile] 405 | \frametitle{Variables: Declaration} 406 | \begin{itemize} 407 | \item 408 | Reserve memory for variable: 409 | {\color{Orange} declaration} 410 | \begin{itemize} 411 | \item ; 412 | \end{itemize} 413 | \item 414 | A variable must be declared {\color{LimeGreen} before} use 415 | \end{itemize} 416 | \begin{minted}[bgcolor=Black]{c} 417 | char test_char; 418 | int sample_int; 419 | long my_long; 420 | double sum, average, total; 421 | int id, counter, value; 422 | \end{minted} 423 | \end{frame} 424 | 425 | \begin{frame} 426 | \frametitle{Variable Type Effect (in complied Lang.)} 427 | \begin{itemize} 428 | \item \textbf{\color{Orange} Important note:} the type of variable is 429 | NOT stored in the main memory 430 | \item After compiling the program, NO type is associated to memory locations!!! 431 | \end{itemize} 432 | \begin{itemize} 433 | \item So, what does do the type?! 434 | \item 435 | It determines the {\color{Green} operations} that work 436 | with the memory location 437 | \end{itemize} 438 | \begin{itemize} 439 | \item 440 | int x, y, z; z = x + y performed by {\color{Cyan} ALU} 441 | \item 442 | float a, b, c; c = a + b performed by {\color{Cyan} FPU} 443 | \end{itemize} 444 | \end{frame} 445 | 446 | \begin{frame} 447 | \frametitle{Variables: Initial Values} 448 | \begin{itemize} 449 | \item What this the initial value of a variable? 450 | \begin{itemize} 451 | \item In C:\@ we do not know 452 | \item In C:\@ it is not 0. 453 | \end{itemize} 454 | \end{itemize} 455 | \begin{block}{} 456 | We need to assign a value to each variable before use it. 457 | \end{block} 458 | \end{frame} 459 | 460 | \section{Values} 461 | 462 | \begin{frame} 463 | \frametitle{Constants in C} 464 | \begin{itemize} 465 | \item Values 466 | \begin{itemize} 467 | \item Integer numbers 468 | \item Float numbers 469 | \item Char 470 | \item Strings 471 | \end{itemize} 472 | \item Symbolic constant 473 | \item Constant variables 474 | \end{itemize} 475 | \end{frame} 476 | 477 | \begin{frame} 478 | \frametitle{Values} 479 | \begin{itemize} 480 | \item Variables 481 | \item Declaration specifies the type and name (identifier) of variable 482 | \item 483 | Assigning value to the variable: 484 | {\color{Orange} assignment} 485 | 486 | \begin{itemize} 487 | \item = ; 488 | \item 489 | Compute the and save result in memory location specified 490 | by 491 | 492 | \end{itemize} 493 | \end{itemize} 494 | \end{frame} 495 | 496 | \begin{frame}[fragile] 497 | \frametitle{Values: Examples} 498 | \begin{minted}[bgcolor=Black]{c} 499 | int i, j; 500 | long l; 501 | float f; 502 | double d; 503 | i = 10; 504 | j = 20; 505 | f = 20.0; 506 | l = 218; 507 | d = 19.9; 508 | \end{minted} 509 | \end{frame} 510 | 511 | \begin{frame} 512 | \frametitle{Value Types} 513 | \begin{itemize} 514 | \item Where are the values stored?! 515 | \begin{itemize} 516 | \item In main memory 517 | \item There is a logical section for these constant values 518 | \end{itemize} 519 | \item So, we need to specify the type of the value 520 | \begin{itemize} 521 | \item The coding of 01s of the value 522 | \end{itemize} 523 | \item The type of value is determined from the value itself 524 | \end{itemize} 525 | \end{frame} 526 | 527 | \begin{frame} 528 | \frametitle{Values: Integers} 529 | \begin{itemize} 530 | \item Valid integer values 531 | \mint{c}|10; -20; +400; 0x12A; 011; 5000L| 532 | \item Invalid integer values 533 | \mint{c}|10.0; -+20; -40 0; 600,000; 5000 L| 534 | \end{itemize} 535 | \end{frame} 536 | 537 | \begin{frame} 538 | \frametitle{Values: Double} 539 | \begin{itemize} 540 | \item Valid numbers: 541 | \mint{c}|0.2; .5; -.67; 20.0; 60e10 (60 * 10^10); 7e-2 (7 * 10^-2)| 542 | \item Invalid numbers: 543 | \mint{c}|0. 2; 20. 0; 20 .0; 7 e; 6e; e12| 544 | \end{itemize} 545 | \end{frame} 546 | 547 | \begin{frame} 548 | \frametitle{Values: Float} 549 | \begin{itemize} 550 | \item Valid numbers: 551 | \mint{c}|0.2f; .5f| 552 | \end{itemize} 553 | \end{frame} 554 | 555 | \begin{frame} 556 | \frametitle{Values: Chars} 557 | \begin{itemize} 558 | \item Char values 559 | \begin{itemize} 560 | \item Should be enclosed in single quotation 561 | \end{itemize} 562 | \item Each character has a code: ASCII code 563 | \item Character vs. Integer 564 | \end{itemize} 565 | \end{frame} 566 | 567 | \begin{frame} 568 | \frametitle{Effect of Value Types} 569 | \begin{itemize} 570 | \item The type of values have the same effect of the type of variables 571 | \item It determines the “operations” that work on the values 572 | \end{itemize} 573 | \end{frame} 574 | 575 | \begin{frame}[fragile] 576 | \frametitle{Basic Input Output} 577 | \begin{itemize} 578 | \item To read something: \mint{c}|scanf| 579 | \item Integer: \mint{c}|scanf("%d", &int_variable);| 580 | \item Float: \mint{c}|scanf("%f", &float_variable);| 581 | \item Double: \mint{c}|scanf("%lf", &double_variable);| 582 | \end{itemize} 583 | \end{frame} 584 | 585 | \begin{frame}[fragile] 586 | \frametitle{Basic Input Output} 587 | \begin{itemize} 588 | \item To print something: \mint{c}|printf| 589 | \item Integer: \mint{c}|printf("%d", int_variable);| 590 | \item Float: \mint{c}|printf("%f", float_variable);| 591 | \item Double \mint{c}|printf("%lf", double_variable);| 592 | \item Message: \mint{c}|printf("message");| 593 | \end{itemize} 594 | \end{frame} 595 | 596 | \section{Casting} 597 | 598 | \begin{frame} 599 | \frametitle{Casting} 600 | \begin{itemize} 601 | \item What is the casting? 602 | \begin{itemize} 603 | \item 604 | When the type of variable and value 605 | {\color{Cyan} are not the same} 606 | \item Example: Assigning double value to integer variable 607 | \end{itemize} 608 | \item It is not a syntax error in C (only warning) 609 | \begin{itemize} 610 | \item But can cause {\color{Orange} runtime errors} 611 | \end{itemize} 612 | \item It is useful (in special situations) 613 | \begin{itemize} 614 | \item But we should be very very careful 615 | \end{itemize} 616 | \end{itemize} 617 | \end{frame} 618 | 619 | \begin{frame}[fragile] 620 | \frametitle{Implicit casting} 621 | \begin{itemize} 622 | \item Implicit 623 | \begin{itemize} 624 | \item We don’t say it 625 | \item But we do it 626 | \end{itemize} 627 | \end{itemize} 628 | \begin{minted}[bgcolor=Black]{c} 629 | char f2 = 50e6; /* cast from double to char */ 630 | int i = 98.01; /* cast from double to int */ 631 | \end{minted} 632 | \end{frame} 633 | 634 | \begin{frame}[fragile] 635 | \frametitle{Explicit casting} 636 | \begin{itemize} 637 | \item Explicit 638 | \begin{itemize} 639 | \item We say it 640 | \item And we do it 641 | \end{itemize} 642 | \end{itemize} 643 | \begin{minted}[bgcolor=Black]{c} 644 | int i = (int) 98.1; /* cast from double to int */ 645 | char c = (char) 90; /* cast from int to char */ 646 | \end{minted} 647 | \end{frame} 648 | 649 | \begin{frame}[fragile] 650 | \frametitle{Casting effects} 651 | \begin{itemize} 652 | \item Casting from small types to large types 653 | \begin{itemize} 654 | \item There is not any problem 655 | \item No loss of data 656 | \end{itemize} 657 | \end{itemize} 658 | \begin{minted}[bgcolor=Black]{c} 659 | int i; 660 | short s; 661 | float f; 662 | double d; 663 | s = 'A'; // s = 65 664 | i = 'B'; // i = 66 665 | f = 4566; // f = 4566.0 666 | d = 5666; // d = 5666.0 667 | \end{minted} 668 | \end{frame} 669 | 670 | \begin{frame}[fragile] 671 | \frametitle{Casting effects (cont’d)} 672 | \begin{itemize} 673 | \item Casting from large types to small types 674 | \begin{itemize} 675 | \item Data loss is possible 676 | \item Depends on the values 677 | \end{itemize} 678 | \end{itemize} 679 | \begin{minted}[bgcolor=Black]{c} 680 | float f = 65536ll; // 65536.0 681 | double d = 65536ll; // 65536.0 682 | short s = 720; // 720 683 | char c = (char) 65536; // c = 0 684 | short s = (short) 65536; // s = 0 685 | int i = 1.22; // i = 1 686 | int j = 1e23; // j = ??? 687 | \end{minted} 688 | \end{frame} 689 | 690 | \section{Constants \& Definition} 691 | 692 | \begin{frame}[fragile] 693 | \frametitle{Constant Variables} 694 | \begin{itemize} 695 | \item Constants 696 | \begin{itemize} 697 | \item Do not want to change the value 698 | \item Example: pi = 3.14 699 | \end{itemize} 700 | \item We can only initialize a constant variable 701 | \begin{itemize} 702 | \item We MUST initialize the constant variables (why?!) 703 | \end{itemize} 704 | \item \textit{\color{LimeGreen} const} is a qualifier 705 | \end{itemize} 706 | \begin{minted}[bgcolor=Black]{c} 707 | const int STUDENTS = 38; 708 | const long int MAX_GRADE = 20; 709 | int i; 710 | i = MAX_GRADE; 711 | STUDENT = 39; //ERROR 712 | \end{minted} 713 | \end{frame} 714 | 715 | \begin{frame}[fragile] 716 | \frametitle{Definitions} 717 | \begin{itemize} 718 | \item Another tool to define constants 719 | \begin{itemize} 720 | \item Definition is not variable 721 | \begin{itemize} 722 | \item We define definition, don’t declare them 723 | \end{itemize} 724 | \item Pre-processor replaces them by their values before compiling 725 | \end{itemize} 726 | \end{itemize} 727 | \begin{minted}[bgcolor=Black]{c} 728 | #define STUDENTS 38 729 | int main(void) { 730 | int i; 731 | i = STUDENTS; 732 | STUDENTS = 90; //ERROR! What compiler sees: 38 = 90 733 | } 734 | \end{minted} 735 | \end{frame} 736 | 737 | \begin{frame} 738 | \frametitle{Summary} 739 | \begin{itemize} 740 | \item Simple programs in C 741 | \item Two basics 742 | \begin{itemize} 743 | \item Variables 744 | \item Values 745 | \end{itemize} 746 | \item Casting 747 | \begin{itemize} 748 | \item The type mismatch 749 | \end{itemize} 750 | \item Constant variables \& definitions 751 | \end{itemize} 752 | \end{frame} 753 | 754 | \begin{frame} 755 | \frametitle{Legends} 756 | \begin{figure} 757 | \includegraphics[height=.75\textheight]{./img/van.jpg} 758 | \end{figure} 759 | \pause% 760 | \centering 761 | \color{Violet} Van Jacobson 762 | \end{frame} 763 | 764 | \begin{frame} 765 | \frametitle{Legends} 766 | \begin{itemize} 767 | \item an American computer scientist 768 | \item renowned for his work on TCP/IP network performance and scaling 769 | \item one of the primary contributors to the TCP/IP protocol stack—the technological foundation of today’s Internet 770 | \end{itemize} 771 | \end{frame} 772 | 773 | \end{document} 774 | -------------------------------------------------------------------------------- /lecture-4/img/ken.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-4/img/ken.jpg -------------------------------------------------------------------------------- /lecture-4/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-4/main.tex: -------------------------------------------------------------------------------- 1 | \documentclass{../c-lecture} 2 | 3 | \subtitle{Calculation} 4 | 5 | \begin{document} 6 | 7 | \begin{frame} 8 | \titlepage{} 9 | \end{frame} 10 | \begin{frame} 11 | \frametitle{Outline} 12 | \tableofcontents{} 13 | \end{frame} 14 | 15 | \section{Basic mathematic operations in C} 16 | 17 | \begin{frame} 18 | \frametitle{Basic operations} 19 | \begin{table} 20 | \begin{tabular}{cc} 21 | \toprule 22 | 23 | Addition & 24 | $+$\\ 25 | 26 | \midrule 27 | 28 | Subtraction & 29 | $-$\\ 30 | 31 | \midrule 32 | 33 | Division & 34 | $/$\\ 35 | 36 | \midrule 37 | 38 | Multiplication & 39 | $*$\\ 40 | 41 | \midrule 42 | 43 | Modulus & 44 | $\%$\\ 45 | 46 | \bottomrule 47 | \end{tabular} 48 | \end{table} 49 | \end{frame} 50 | 51 | \begin{frame} 52 | \frametitle{Modulo} 53 | \begin{itemize} 54 | \item Only can be used by \textbf{\color{Orange} int} operands 55 | \begin{itemize} 56 | \item $5 \% 4 = 1$ 57 | \item $7 \% 88 = 7$ 58 | \item $-20 \% 7 = -6$ 59 | \item $20 \% -7 = 6$ 60 | \item $-20 \% -7 = -6$ 61 | \end{itemize} 62 | \end{itemize} 63 | \end{frame} 64 | 65 | \begin{frame}[fragile] 66 | \frametitle{Mean of 3 Numbers} 67 | \begin{minted}[bgcolor=Black]{c} 68 | #include 69 | int main(void) { 70 | float num1, num2, num3, sum, average; 71 | printf("Enter 3 number: \n"); 72 | scanf("%f",&num1); 73 | scanf("%f",&num2); 74 | scanf("%f",&num3); 75 | sum = num1 + num2 + num3; 76 | average = sum / 3; 77 | printf("mean = "); 78 | printf("%f\n", average); 79 | return 0; 80 | } 81 | \end{minted} 82 | \end{frame} 83 | 84 | \section{Effect of type and type conversion} 85 | 86 | \begin{frame} 87 | \frametitle{General rules of type conversion} 88 | \begin{itemize} 89 | \item 90 | If either operand is \textit{\color{Orange} long double}, 91 | convert the other to \textit{\color{Orange} long double}. 92 | 93 | \item 94 | Otherwise, if either operand is \textit{\color{LimeGreen} double}, 95 | convert the other to \textit{\color{LimeGreen} double}. 96 | 97 | \item 98 | Otherwise, if either operand is \textit{\color{Cyan} float}, 99 | convert the other to \textit{\color{Cyan} float}. 100 | 101 | \item 102 | Otherwise, convert \textit{\color{Orange} char} and 103 | \textit{\color{Orange} short} to 104 | \textit{\color{Orange} int}. 105 | 106 | \item 107 | Then, if either operand is \textit{\color{LimeGreen} long}, convert 108 | the other to \textit{\color{LimeGreen} long}. 109 | \end{itemize} 110 | \end{frame} 111 | 112 | \begin{frame} 113 | \frametitle{Effect of types} 114 | \begin{itemize} 115 | \item Type of operands determines the type of the result 116 | \begin{itemize} 117 | \item The type of output is the type of operands (after conversion) 118 | \end{itemize} 119 | \item int int $\Rightarrow$ int 120 | \item int long $\Rightarrow$ long 121 | \item float float $\Rightarrow$ float 122 | \item float int $\Rightarrow$ float 123 | \item double float $\Rightarrow$ double 124 | \end{itemize} 125 | \end{frame} 126 | 127 | \begin{frame} 128 | \frametitle{Effect of types} 129 | \begin{itemize} 130 | \item 131 | If both operand of division ($/$) is \textit{\color{Orange} int} 132 | \item \textrightarrow\ data lost 133 | \end{itemize} 134 | \end{frame} 135 | 136 | \begin{frame} 137 | \frametitle{Effect of types \& Explicit casts} 138 | \begin{table} 139 | \begin{tabular}{ccc} 140 | \toprule 141 | 142 | Expression & 143 | Result & 144 | Type of result \\ 145 | 146 | \midrule 147 | 148 | $(double) 1 + 2.0f$ & 149 | $3.0$ & 150 | $double$ \\ 151 | 152 | \midrule 153 | 154 | $(int) 2.69 + 4$ & 155 | $6$ & 156 | $int$ \\ 157 | 158 | \midrule 159 | 160 | $(double) 1 / 2$ & 161 | $0.5$ & 162 | $double$ \\ 163 | 164 | \midrule 165 | 166 | $1 / (int) 2.0$ & 167 | $0$ & 168 | $int$ \\ 169 | 170 | \midrule 171 | 172 | $(double) (1 / 2)$ & 173 | $0.0$ & 174 | $double$ \\ 175 | 176 | \midrule 177 | 178 | $(int)((double) 1 / 2)$ & 179 | $0$ & 180 | $int$ \\ 181 | 182 | \bottomrule 183 | \end{tabular} 184 | \end{table} 185 | \end{frame} 186 | 187 | \section{Precedence} 188 | 189 | \begin{frame} 190 | \frametitle{Precedence} 191 | \begin{enumerate} 192 | \item Parenthesis 193 | \item Unary $+$ $-$ (for sign): $+4$, $-8$ 194 | \item Explicit casting 195 | \item $/$ $*$ $\%$ 196 | \item Binary $+$ $-$: $4 + 8$ 197 | \item If multiple $+$ $-$ or $/$ $*$ $\%$: from left to right 198 | \end{enumerate} 199 | \end{frame} 200 | 201 | \begin{frame}[fragile] 202 | \begin{minted}[bgcolor=Black]{c} 203 | #include 204 | 205 | int main(void){ 206 | double num1, num2; 207 | int sum; 208 | printf("Enter 2 number: \n"); 209 | scanf("%lf", &num1); 210 | scanf("%lf", &num2); 211 | sum = (int)num1 + (int)num2; 212 | printf("%d\n", sum); 213 | return 0; 214 | } 215 | \end{minted} 216 | \end{frame} 217 | 218 | \begin{frame}[fragile] 219 | \begin{minted}[bgcolor=Black]{c} 220 | #include 221 | 222 | int main(void){ 223 | double num1, num2, fpart1, fpart2, sum; 224 | printf("Enter 2 number: \n"); 225 | scanf("%lf", &num1); 226 | scanf("%lf", &num2); 227 | fpart1 = num1 - (int)num1; 228 | fpart2 = num2 - (int)num2; 229 | sum = fpart1 + fpart2; 230 | printf("%lf\n", sum); 231 | return 0; 232 | } 233 | \end{minted} 234 | \end{frame} 235 | 236 | \section{Advanced mathematical operations} 237 | 238 | \begin{frame}[fragile] 239 | \frametitle{Increment \& Decrement of Variables} 240 | \begin{itemize} 241 | \item Unary operators only for variables 242 | \item $++$: increase by one 243 | \item $--$: decrease by one 244 | \end{itemize} 245 | \begin{minted}[bgcolor=Black]{c} 246 | int i = 10; 247 | i = i + 1; // i = 11 248 | i++; // i = 12 249 | ++i; // i = 13 250 | i--; // i = 12 251 | --i; // i = 11 252 | i = i - 1; // i = 10 253 | \end{minted} 254 | \end{frame} 255 | 256 | \begin{frame}[fragile] 257 | \frametitle{Increment \& Decrement (cont’d)} 258 | \begin{itemize} 259 | \item 260 | {\color{Cyan} Postfix:} Use the value then apply the 261 | operator 262 | \item 263 | {\color{Cyan} Prefix:} Apply the operator then use the value 264 | \end{itemize} 265 | \begin{minted}[bgcolor=Black]{c} 266 | int i = 10, k = 6, j; 267 | j = i + 1; // i = 10, j = 11 268 | j = i++; // i = 11, j = 10 269 | j = ++i; // i = 12, j = 12 270 | j = i--; // i = 11, j = 12 271 | j = --i; // i = 10, j = 10 272 | j = i - 1; // i = 10, j = 9 273 | \end{minted} 274 | \end{frame} 275 | 276 | \begin{frame}[fragile] 277 | \frametitle{Assignment Combined with Operation} 278 | \begin{itemize} 279 | \item These are equal 280 | \begin{itemize} 281 | \item = ; 282 | \item 283 | = () 284 | \end{itemize} 285 | \end{itemize} 286 | \begin{minted}[bgcolor=Black]{c} 287 | int i = 9, j = 20; 288 | i += 1; // i = i + 1; i = 10 289 | j /= i; // j = j / i; j = 2 290 | i *= i + j - 6 + i / j; 291 | /*i = i * (i + j - 6 + (i / j)); i = 110*/ 292 | \end{minted} 293 | \end{frame} 294 | 295 | \begin{frame}[fragile] 296 | \frametitle{Multiple assignment} 297 | \begin{itemize} 298 | \item More than one assignment in a statement 299 | \begin{itemize} 300 | \item From right to left 301 | \end{itemize} 302 | \end{itemize} 303 | \scriptsize 304 | \begin{minted}[bgcolor=Black]{c} 305 | int i, j, k, l; 306 | i = j = k = l = 1; 307 | i += j *= --k -= 3 / l; 308 | // step 1 309 | i += j *= --k -= 3 310 | // step 2 311 | i += j *= --(k -= 3) // [k = -2] 312 | // step 3 313 | i += j *= --k // [k = -3] 314 | // step 3 315 | i += j *= -3 // [j = -3] 316 | // step 4 317 | i += -3 // [i = -2] 318 | // result 319 | // i = -2, j = -3, k = -3, l = 1 320 | \end{minted} 321 | \end{frame} 322 | 323 | \begin{frame} 324 | \frametitle{Precedence} 325 | \begin{table} 326 | \begin{tabular}{cc} 327 | \toprule 328 | 329 | Operator & 330 | Direction \\ 331 | 332 | \midrule 333 | 334 | $( )$& 335 | \\ 336 | 337 | \midrule 338 | 339 | $++$ $--$ $(type)$ & 340 | \\ 341 | 342 | \midrule 343 | 344 | $*$ $/$ $\%$ & 345 | Left to Right \\ 346 | 347 | \midrule 348 | 349 | $+$ $-$ & 350 | Left to Right \\ 351 | 352 | \midrule 353 | 354 | $+=$ $-=$ $*=$ $/=$ $\%=$ & 355 | Right to Left \\ 356 | 357 | \bottomrule 358 | \end{tabular} 359 | \end{table} 360 | \end{frame} 361 | 362 | \begin{frame}[fragile] 363 | \frametitle{Arithmetic on characters} 364 | \begin{itemize} 365 | \item \mintinline{c}|char| can be used as 8-bit integer 366 | \item All arithmetic operation can be used with characters 367 | \end{itemize} 368 | \begin{minted}[bgcolor=Black]{c} 369 | /* A: 65, B: 66, C: 67, … */ 370 | char c = 'A', ch; 371 | int i; 372 | c++; // c = 66, c = 'B' 373 | ch = c; 374 | ch += 3; // ch = 69, ch = 'E' 375 | i = c - ch + 'X' - 'Z'; // i = -5 376 | \end{minted} 377 | \end{frame} 378 | 379 | \begin{frame} 380 | \frametitle{sizeof operator} 381 | \begin{itemize} 382 | \item \mintinline{c}|sizeof| is a unary operator 383 | \begin{itemize} 384 | \item Return the size of operand in bytes 385 | \item Operand can be {\color{Cyan} variable, value or type} 386 | \item The operand inside the \mintinline{c}|sizeof()| operator is not evaluated 387 | \end{itemize} 388 | \end{itemize} 389 | \end{frame} 390 | 391 | \begin{frame}[fragile] 392 | \frametitle{sizeof operator} 393 | \begin{minted}[bgcolor=Black]{c} 394 | int size, i = 10; 395 | size = sizeof i; // 4 396 | size = sizeof(i); // 4 397 | size = sizeof(2000); // 4 398 | size = sizeof(char); // 1 399 | \end{minted} 400 | \end{frame} 401 | 402 | \begin{frame} 403 | \frametitle{Precedence} 404 | \begin{table} 405 | \begin{tabular}{cc} 406 | \toprule 407 | 408 | Operator & 409 | Direction \\ 410 | 411 | \midrule 412 | 413 | $( )$& 414 | \\ 415 | 416 | \midrule 417 | 418 | $++$ $--$ $(type)$ $sizeof()$ & 419 | \\ 420 | 421 | \midrule 422 | 423 | $*$ $/$ $\%$ & 424 | Left to Right \\ 425 | 426 | \midrule 427 | 428 | $+$ $-$ & 429 | Left to Right \\ 430 | 431 | \midrule 432 | 433 | $+=$ $-=$ $*=$ $/=$ $\%=$ & 434 | Right to Left \\ 435 | 436 | \bottomrule 437 | \end{tabular} 438 | \end{table} 439 | \end{frame} 440 | 441 | \begin{frame}[fragile] 442 | \frametitle{Undefined Statements} 443 | \begin{itemize} 444 | \item 445 | When standard does \textbf{\color{RubineRed} not} tell what will 446 | happen 447 | \item Examples 448 | \end{itemize} 449 | \begin{minted}[bgcolor=Black]{c} 450 | int i, j, k; 451 | 452 | k = i = 10; 453 | j = i++ + k + --i; // j = 29 or 30? 454 | 455 | i = j = 10; 456 | i = j + i++; // i = 11 or ??? 457 | \end{minted} 458 | \end{frame} 459 | 460 | \begin{frame} 461 | \frametitle{Overflow and Underflow} 462 | \begin{itemize} 463 | \item Computer's precision is limited 464 | \begin{itemize} 465 | \item 466 | {\color{Orange} The number of bits} in each type is 467 | limited 468 | \item double [-1e308, 1e308] 469 | \end{itemize} 470 | \item Overflow 471 | \begin{itemize} 472 | \item When result is larger than specified ranges 473 | \item 1e300 * 1e200 474 | \end{itemize} 475 | \item Underflow 476 | \begin{itemize} 477 | \item When the result is too smaller than precision 478 | \item 1e-300 * 1e-200 479 | \end{itemize} 480 | \end{itemize} 481 | \end{frame} 482 | 483 | \begin{frame}[fragile] 484 | \frametitle{Quadratic Term} 485 | \begin{minted}[bgcolor=Black]{c} 486 | #include 487 | 488 | int main(void){ 489 | double a, b, c, x, result; 490 | printf("Enter a, b, c, x: "); 491 | scanf("%lf", &a); 492 | scanf("%lf", &b); 493 | scanf("%lf", &c); 494 | scanf("%lf", &x); 495 | result = a * x * x + b * x + c; 496 | printf("%lf\n", result); 497 | return 0; 498 | } 499 | \end{minted} 500 | \end{frame} 501 | 502 | \section{Mathematic library} 503 | 504 | \begin{frame}[fragile] 505 | \frametitle{Math library} 506 | \begin{itemize} 507 | \item \mint{c}|#include | 508 | \end{itemize} 509 | \scriptsize 510 | \begin{minted}[bgcolor=Black]{c} 511 | double f = 36; 512 | fabs(-f) // 36.000000 513 | sqrt(f) // 6.00000 514 | pow(f, 0.5) // 6.000000 515 | ceil(-10.2) // -10.000000 516 | ceil(10.2) // 11.000000 517 | floor(-10.2) // -11.000000 518 | floor(10.2) // 10.000000 519 | fmax(10.1, 20.2) // 20.2 520 | fmin(10.1, 20.2) // 10.1 521 | rint(10.2) // 10.0 522 | rint(-10.2) // -10.0 523 | rint(20.6) // 21.0 524 | rint(-20.6) // -21.0 525 | \end{minted} 526 | \end{frame} 527 | 528 | \begin{frame}[fragile] 529 | \frametitle{Math library} 530 | \begin{minted}[bgcolor=Black]{c} 531 | const double PI = 3.141592653589793; 532 | const double E = 2.7182818284590451; 533 | 534 | // M_PI, M_E are defined in math.h 535 | 536 | sin(PI) // 0.000000 537 | cos(PI/2) // 0.000000 538 | acos(1) // 0.000000 539 | log(E) // 1.000000 540 | log(10) // 2.30258 541 | exp(1) // 2.718282 542 | \end{minted} 543 | \end{frame} 544 | 545 | \begin{frame}[fragile] 546 | \frametitle{Perimeter and Area of Circle} 547 | \begin{minted}[bgcolor=Black]{c} 548 | #include 549 | #include 550 | 551 | int main(void){ 552 | double r; 553 | printf("Enter Radius"); 554 | scanf("%lf", &r); 555 | double area = M_PI * pow(r, 2); 556 | double perimeter = 2 * M_PI * r; 557 | printf("Area = %lf\n", area); 558 | printf("Perimeter = %lf\n", perimeter); 559 | return 0; 560 | } 561 | \end{minted} 562 | \end{frame} 563 | 564 | \section{Random Numbers} 565 | 566 | \begin{frame}[fragile] 567 | \frametitle{Random Numbers} 568 | \begin{itemize} 569 | \item \mint{c}|#include | 570 | \item \mint{c}|rand()| 571 | \begin{itemize} 572 | \item A random number in $[0, RAND\_MAX]$ 573 | \end{itemize} 574 | \item How does it work 575 | \begin{itemize} 576 | \item Start from a {\color{Orange} seed\_number} 577 | \item $X_0 = F(seed\_number)$ 578 | \item $X_{n + 1} = F(X_n)$ 579 | \end{itemize} 580 | \item Same seed 581 | \begin{itemize} 582 | \item Same random number sequence 583 | \end{itemize} 584 | \end{itemize} 585 | \end{frame} 586 | 587 | \begin{frame}[fragile] 588 | \frametitle{Random Numbers} 589 | \begin{itemize} 590 | \item We usually want different random number 591 | \begin{itemize} 592 | \item Run 1: 10, 20, 17, 1000, 23, 345, 30 593 | \item Run 2: 23, 904, 23, 346, 85, 234, 63 594 | \end{itemize} 595 | \item We should use different seed in each run 596 | \begin{itemize} 597 | \item How? 598 | \item Initialize seed by system time 599 | \end{itemize} 600 | \end{itemize} 601 | \begin{minted}[bgcolor=Black]{c} 602 | #include 603 | time_t t = time(NULL); 604 | srand(t); 605 | \end{minted} 606 | \end{frame} 607 | 608 | \begin{frame}[fragile] 609 | \frametitle{Random Numbers} 610 | \scriptsize 611 | \begin{minted}[bgcolor=Black]{c} 612 | #include 613 | #include 614 | #include 615 | 616 | int main(void) { 617 | int r1, r2; 618 | srand(0); 619 | r1 = rand(); 620 | printf("r1 = %d\n", r1); 621 | time_t t = time(NULL); 622 | srand(t); 623 | r2 = rand(); 624 | printf("r2 = %d\n", r2); 625 | return 0; 626 | } 627 | \end{minted} 628 | \end{frame} 629 | 630 | \begin{frame} 631 | \frametitle{Random Numbers} 632 | \begin{itemize} 633 | \item First Run 634 | \begin{itemize} 635 | \item r1 = 38 636 | \item r2 = 1873 637 | \end{itemize} 638 | \item Second Run 639 | \begin{itemize} 640 | \item r1 = 38 641 | \item r2 = 1866 642 | \end{itemize} 643 | \item Third Run 644 | \begin{itemize} 645 | \item r1 = 38 646 | \item r2 = 1860 647 | \end{itemize} 648 | \end{itemize} 649 | \end{frame} 650 | 651 | \section{Type-generic math} 652 | 653 | \begin{frame} 654 | \frametitle{\textit{tgmath.h}} 655 | \begin{itemize} 656 | \item The header \textit{\color{Orange} } includes the headers \textit{\color{LimeGreen} } and \textit{\color{LimeGreen} } 657 | and defines several type-generic macros that determine which real or, when applicable, complex function to call based on the types of the arguments. 658 | \item Each of the arguments provided for these generic parameters that is of an integer type is casted to a double; 659 | Arguments of floating-point types are used without transformation (directly as float, double or long double). 660 | \item real function: 661 | \begin{itemize} 662 | \item \textit{float} variant XXXf 663 | \item \textit{double} variant XXX 664 | \item \textit{long double} variant XXXl 665 | \end{itemize} 666 | \end{itemize} 667 | \end{frame} 668 | 669 | \begin{frame} 670 | \frametitle{fabs} 671 | \begin{itemize} 672 | \item fabsf --- float 673 | \item fabs --- double 674 | \item fabsl --- long double 675 | \end{itemize} 676 | \end{frame} 677 | 678 | \begin{frame} 679 | \frametitle{Legends} 680 | \begin{figure} 681 | \includegraphics[height=.75\textheight]{./img/ken.jpg} 682 | \end{figure} 683 | \pause% 684 | \centering 685 | \color{Violet} Ken Thompson 686 | \end{frame} 687 | 688 | \begin{frame} 689 | \frametitle{Legends} 690 | \begin{itemize} 691 | \item he designed and implemented the original Unix operating system. 692 | \item he worked at Google, where he co-developed the Go programming language. 693 | \item he worked on regular expressions and early computer text editors QED and ed. 694 | \end{itemize} 695 | \end{frame} 696 | 697 | \end{document} 698 | -------------------------------------------------------------------------------- /lecture-5/img/ghodsi.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-5/img/ghodsi.jpg -------------------------------------------------------------------------------- /lecture-5/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-5/main.tex: -------------------------------------------------------------------------------- 1 | \documentclass{../c-lecture} 2 | 3 | \subtitle{Interaction} 4 | 5 | \begin{document} 6 | 7 | \begin{frame} 8 | \titlepage{} 9 | \end{frame} 10 | \begin{frame} 11 | \frametitle{Outline} 12 | \tableofcontents{} 13 | \end{frame} 14 | 15 | \section{Produce output} 16 | 17 | \begin{frame}[fragile] 18 | \frametitle{Printing} 19 | \begin{itemize} 20 | \item Printing messages 21 | \begin{itemize} 22 | \item \mint{c}|printf("This is message \n");| 23 | \end{itemize} 24 | \item Printing variables 25 | \begin{itemize} 26 | \item \mint{c}|printf("format", parameters);| 27 | \end{itemize} 28 | \end{itemize} 29 | \begin{minted}[bgcolor=Black]{c} 30 | int i = 20; 31 | char c = 'a'; 32 | printf("%d, %c", i, c); 33 | printf("i is %d and char is %c", i, '6'); 34 | \end{minted} 35 | \end{frame} 36 | 37 | \begin{frame}[fragile] 38 | \frametitle{Printing Integers} 39 | \begin{itemize} 40 | \item \mint{c}|%d, %i, %ld| 41 | \end{itemize} 42 | \begin{minted}[bgcolor=Black]{c} 43 | long long int a = 10; 44 | printf("%d", 100); 45 | // 100 46 | printf("%d, %d", +1000, -100); 47 | // 1000, -100 48 | printf("%i", 100); 49 | // 100 50 | printf("%ld, %i", +1000l, -100); 51 | // 1000, -100 52 | printf("%lld", a); 53 | // 10 54 | \end{minted} 55 | \end{frame} 56 | 57 | \begin{frame}[fragile] 58 | \frametitle{Printing Unsigned Integers} 59 | \begin{itemize} 60 | \item \mint{c}|%u (base 10), %o (base 8), %x (base 16) and %X (base 16)| 61 | \end{itemize} 62 | \begin{minted}[bgcolor=Black]{c} 63 | unsigned int i = 26; 64 | printf("%u\n", i); // 26 65 | printf("%o\n", i); // 32 66 | printf("%x\n", i); // 1a 67 | printf("%X\n", i); // 1A 68 | \end{minted} 69 | \end{frame} 70 | 71 | \begin{frame}[fragile] 72 | \frametitle{Printing Floats} 73 | \begin{itemize} 74 | \item \mint{c}|%f, %e, %E, %lf| 75 | \end{itemize} 76 | \begin{minted}[bgcolor=Black]{c} 77 | printf("%f", 100.5f); 78 | // 100.500000 79 | 80 | float f = -2; 81 | double d = 100; 82 | printf("%f, %f", f, d); 83 | // -2.000000, 100.000000 84 | printf("%f, %e, %E", 1e3, 1e3, 1e10); 85 | // 1000.000000, 1.000000e+03, 1.000000E+10 86 | \end{minted} 87 | \end{frame} 88 | 89 | \begin{frame}[fragile] 90 | \frametitle{Printing Chars} 91 | \begin{itemize} 92 | \item \mint{c}|%c| 93 | \end{itemize} 94 | \begin{minted}[bgcolor=Black]{c} 95 | printf("%c", 'a'); 96 | // a 97 | 98 | printf("%c, %c", 'a','b'); 99 | // a, b 100 | 101 | char c1 = 'a'; 102 | printf("%c, %c, %c", c1, 'b', 65); 103 | // a, b, A 104 | \end{minted} 105 | \end{frame} 106 | 107 | \begin{frame}[fragile] 108 | \frametitle{Special Character} 109 | \begin{table} 110 | \begin{tabular}{cc} 111 | \toprule 112 | 113 | Characters in \textit{\color{Orange} printf} & 114 | result \\ 115 | 116 | \midrule 117 | 118 | \mintinline{c}|'\n'| & 119 | newline \\ 120 | 121 | \midrule 122 | 123 | \mintinline{c}|'\r'| & 124 | carriage return \\ 125 | 126 | \midrule 127 | 128 | \mintinline{c}|'\b'| & 129 | backspace \\ 130 | 131 | \midrule 132 | 133 | \mintinline{c}|"\""| & 134 | '' \\ 135 | 136 | \midrule 137 | 138 | \mintinline{c}|"%%"| & 139 | \% \\ 140 | 141 | \midrule 142 | 143 | \mintinline{c}|"\%"| & 144 | \% \\ 145 | 146 | \bottomrule 147 | \end{tabular} 148 | \end{table} 149 | \end{frame} 150 | 151 | \begin{frame}[fragile] 152 | \frametitle{Printing Strings} 153 | \begin{itemize} 154 | \item \mint{c}|%s| 155 | \end{itemize} 156 | \begin{minted}[bgcolor=Black]{c} 157 | printf("This is message"); 158 | // This is message 159 | 160 | printf("This is %s", "message"); 161 | // This is message 162 | 163 | char str1[20] = "This is message"; 164 | printf("%s", str1); 165 | // This is message 166 | \end{minted} 167 | \end{frame} 168 | 169 | \begin{frame} 170 | \frametitle{Field length} 171 | \begin{itemize} 172 | \item Field length is a \textbf{\color{Orange} number} 173 | \item Comes after \% (and before the type char) 174 | \item 175 | It is the \textbf{\color{Green} minimum} space reserved for print 176 | 177 | \begin{itemize} 178 | \item If value is smaller than the space 179 | \begin{itemize} 180 | \item Empty space 181 | \end{itemize} 182 | \item If value is larger than the space 183 | \begin{itemize} 184 | \item No effect 185 | \end{itemize} 186 | \end{itemize} 187 | \end{itemize} 188 | \end{frame} 189 | 190 | \begin{frame}[fragile] 191 | \frametitle{Field length} 192 | \begin{minted}[bgcolor=Black]{c} 193 | printf("|%4d|\n", 1); // | 1| 194 | printf("|%4d|\n", 12345); // |12345| 195 | printf("|%4d|\n", -12345); // |-12345| 196 | printf("|%4lf|\n", 1234.0); // |1234.000000| 197 | printf("|%15lf|\n", 1234.0); // | 1234.000000| 198 | printf("|%4c|\n", 'A'); // | A| 199 | printf("|%4s|\n", "ABC"); // | ABC| 200 | printf("|%4s|\n", "ABCDE"); // |ABCDE| 201 | \end{minted} 202 | \end{frame} 203 | 204 | \begin{frame} 205 | \frametitle{Precision} 206 | \begin{itemize} 207 | \item Precision is a \textit{\color{LimeGreen} .number} and comes after \% 208 | 209 | \item For Integer 210 | \begin{itemize} 211 | \item The \textit{\color{LimeGreen} minimum} number of digits 212 | \item If (\# of digits < precision) then empty space filled with 0 213 | \end{itemize} 214 | 215 | \item For floats 216 | \begin{itemize} 217 | \item With \%f, \%e 218 | \item The number of digits \textbf{\color{Cyan} after .} 219 | \end{itemize} 220 | 221 | \item For strings 222 | \begin{itemize} 223 | \item The \textbf{\color{Orange} maximum} number of characters 224 | \end{itemize} 225 | \end{itemize} 226 | \end{frame} 227 | 228 | \begin{frame}[fragile] 229 | \frametitle{Precision} 230 | \begin{minted}[bgcolor=Black]{c} 231 | printf("|%.4d|\n", 1); // |0001| 232 | printf("|%.4d|\n", 12345); // |12345| 233 | printf("|%.4d|\n", -12345); // |-12345| 234 | printf("|%.4lf|\n", 1234.0); // |1234.0000| 235 | printf("|%.10lf|\n", 1234.0); // |1234.0000000000| 236 | printf("|%.4s|\n", "ABC"); // |ABC| 237 | printf("|%.4s|\n", "ABCDEF"); // |ABCD| 238 | \end{minted} 239 | \end{frame} 240 | 241 | \begin{frame} 242 | \frametitle{Field length and Precision} 243 | \begin{itemize} 244 | \item This is a number with format \textit{\color{Cyan} a.b} 245 | \item First \textit{\color{Orange} b} determines the precision 246 | \item Then \textit{\color{LimeGreen} a} specifies the field length 247 | \end{itemize} 248 | \end{frame} 249 | 250 | \begin{frame}[fragile] 251 | \frametitle{Field length and Precision} 252 | \begin{minted}[bgcolor=Black]{c} 253 | printf("|%10.5d|\n", 12); // | 00012| 254 | printf("|%3.5d|\n", 12); // |00012| 255 | printf("|%10.5lf|\n", 1.234567890123); // | 1.23457| 256 | printf("|%0.5f|\n", 1.234567890123); // |1.23457| 257 | printf("|%15.10s|\n", "Hello, world"); // | Hello, wor| 258 | printf("|%5.10s|\n", "Hello, world"); // |Hello, wor| 259 | \end{minted} 260 | \end{frame} 261 | 262 | \begin{frame} 263 | \frametitle{\textit{\%g for doubles}} 264 | \begin{itemize} 265 | \item The double argument is converted in style f or e (or F or E for G conversions). 266 | \item The precision specifies the number of significant digits. 267 | \item If the precision is missing, 6 digits are given; if the precision is zero, it is treated as 1. 268 | \item Style e is used if the exponent from its conversion is less than -4 or greater than or equal to the precision. 269 | \item Trailing zeros are removed from the fractional part of the result; a decimal point appears only if it is followed by at least one digit. 270 | \end{itemize} 271 | \end{frame} 272 | 273 | \begin{frame}[fragile] 274 | \frametitle{Variable Field Length \& Precision: *} 275 | \begin{itemize} 276 | \item 277 | * can be used to specify field length and precision which is replaced by a 278 | variable 279 | \end{itemize} 280 | \begin{minted}[bgcolor=Black]{c} 281 | int i = 30; 282 | int j = 2; 283 | float f = 1.23456789; 284 | printf("%0*.*f\n", i, j, f); 285 | 286 | // 000000000000000000000000001.23 287 | \end{minted} 288 | \end{frame} 289 | 290 | \begin{frame}[fragile] 291 | \frametitle{PI with user-defined precision} 292 | \inputminted[bgcolor=Black]{c}{./src/pi.c} 293 | \end{frame} 294 | 295 | \begin{frame}[fragile] 296 | \frametitle{Cast in printing (do NOT use)} 297 | \begin{minted}[bgcolor=Black]{c} 298 | int i = -60; 299 | unsigned int j = 4147482648; 300 | float f = -700.05; 301 | 302 | printf("i = %f\n", i); // i = 0.000000 303 | printf("i = %u\n", i); // i = 4294967236 304 | printf("j = %d\n", j); // j = -147484648 305 | printf("f = %d\n", f); // f = -762932576 306 | \end{minted} 307 | \end{frame} 308 | 309 | \section{Get input values} 310 | 311 | \begin{frame}[fragile] 312 | \frametitle{Reading} 313 | \begin{itemize} 314 | \item Read from keyboard (console) 315 | \item What should be determined in reading 316 | \begin{itemize} 317 | \item Keyboard enters ``characters'', so, how to read int, char, …? 318 | \item Which type the chars should be converted? 319 | \item Where should be saved? 320 | \end{itemize} 321 | \item \mint{c}|scanf("format", parameters)| 322 | \begin{itemize} 323 | \item Format: The type that input should be converted to 324 | \item Parameters: Where should be saved 325 | \end{itemize} 326 | \item scanf blocks until ‘Enter’ at the end of input (why?!) 327 | \item Reads from beginning until to white spaces (except reading chars) 328 | \end{itemize} 329 | \end{frame} 330 | 331 | \begin{frame}[fragile] 332 | \frametitle{Reading Integers (base 10)} 333 | \begin{itemize} 334 | \item \mint{c}|%d, %u, %ld, %lu| 335 | \end{itemize} 336 | \begin{minted}[bgcolor=Black]{c} 337 | int i; 338 | unsigned int j; 339 | long int l; 340 | scanf("%d", &i); // -90 341 | scanf("%u", &j); // 78 342 | scanf("%ld", &l); // 60 343 | 344 | // -90 is saved in memory location i 345 | // 78 is saved in memory location j 346 | // 60 is saved in memory location l 347 | 348 | \end{minted} 349 | \begin{block}{} 350 | Spaces at the beginning are ignored 351 | \end{block} 352 | \end{frame} 353 | 354 | \begin{frame}[fragile] 355 | \frametitle{Reading Integers (cont’d)} 356 | \begin{itemize} 357 | \item \mint{c}|%o, %x, %X, %i| 358 | \end{itemize} 359 | \begin{minted}[bgcolor=Black]{c} 360 | scanf("%o", &i); 361 | // Input: 12 -> i = 10 362 | 363 | scanf("%x", &i); 364 | // Input: 1a -> i = 26 365 | 366 | scanf("%i", &i); 367 | // Input: 12 -> i = 12 368 | // Input: 012 -> i = 10 (It reads in base 8) 369 | // Input: 0x12 -> i = 18 (It reads in base 16) 370 | \end{minted} 371 | \end{frame} 372 | 373 | \begin{frame}[fragile] 374 | \frametitle{Reading floats and doubles} 375 | \begin{itemize} 376 | \item \mint{c}|%f, %lf, %e| 377 | \end{itemize} 378 | \begin{minted}[bgcolor=Black]{c} 379 | float f; 380 | double d; 381 | scanf("%f", &f); 382 | scanf("%lf", &d); 383 | 384 | // 90.9 -> 90.9 is saved in memory f 385 | // 88.123456789 -> 88.123456789 saved in memory d 386 | \end{minted} 387 | \begin{block}{} 388 | Spaces at the beginning are ignored 389 | \end{block} 390 | \end{frame} 391 | 392 | \begin{frame}[fragile] 393 | \frametitle{Reading floats and doubles} 394 | \begin{minted}[bgcolor=Black]{c} 395 | float f1, f2; 396 | scanf("%f", &f1); 397 | scanf("%e", &f2); 398 | 399 | // 1.23 -> f1 = 1.23 400 | // 4.56 -> f2 = 4.56 401 | 402 | // 1.23e+1 -> f1 = 12.3 403 | // 4.56e-1 -> f2 = 0.456 404 | \end{minted} 405 | \end{frame} 406 | 407 | \begin{frame}[fragile] 408 | \frametitle{Reading chars} 409 | \begin{itemize} 410 | \item \mint{c}|%c| 411 | \end{itemize} 412 | \begin{minted}[bgcolor=Black]{c} 413 | char c1, c2, c3; 414 | scanf("%c", &c1); /* spaces */ 415 | scanf("%c", &c2); 416 | scanf("%c", &c3); 417 | 418 | // azb → 419 | // c1 = 'a' 420 | // c2 = 'z' 421 | // c3 = 'b' 422 | \end{minted} 423 | \begin{block}{} 424 | Spaces at the beginning are NOT ignored 425 | \end{block} 426 | \end{frame} 427 | 428 | \begin{frame}[fragile] 429 | \frametitle{Reading chars (cont’d)} 430 | \begin{itemize} 431 | \item White spaces (space, tab, enter) are not ignored when reading char 432 | \item To ignore white spaces, use '' `` before \%c 433 | \end{itemize} 434 | \begin{minted}[bgcolor=Black]{c} 435 | scanf("%d%c%d", &i, &c, &j); 436 | // Input: 123 45 -> I = 123 c = ‘ ‘ j = 45 437 | 438 | scanf("%d %c%d", &i, &c, &j); 439 | // Input: 123 4 56 -> I = 123 c = ‘4’ j = 56 440 | // Input: 123 456 -> I = 123 c = ‘4’ j = 56 441 | \end{minted} 442 | \end{frame} 443 | 444 | \begin{frame}[fragile] 445 | \frametitle{Reading chars (cont’d)} 446 | \scriptsize 447 | \inputminted[bgcolor=Black]{c}{./src/read-with-whitespaces.c} 448 | \end{frame} 449 | 450 | \begin{frame}[fragile] 451 | \frametitle{Reading chars (cont’d)} 452 | \begin{minted}[bgcolor=Black]{output} 453 | > 10 ,90 454 | > p 455 | d1 = 10, d2 = 90, c1 = ",", c2 = "p" 456 | \end{minted} 457 | \begin{minted}[bgcolor=Black]{output} 458 | > 10 90 459 | > p 460 | d1 = 10, d2 = 0, c1 = "9", c2 = "p" 461 | \end{minted} 462 | \begin{minted}[bgcolor=Black]{output} 463 | > 10 ,90, 464 | d1 = 10, d2 = 90, c1 = ",", c2 = "," 465 | \end{minted} 466 | \end{frame} 467 | 468 | \begin{frame} 469 | \frametitle{Reading chars (cont’d)} 470 | \begin{itemize} 471 | \item \mintinline{c}|getchar()| 472 | \begin{itemize} 473 | \item Read char \textbf{\color{Orange} after Enter} 474 | \end{itemize} 475 | \item \mintinline{c}|getch()| 476 | \begin{itemize} 477 | \item 478 | Read char \textbf{\color{Orange} without Enter}, 479 | \textbf{\color{LimeGreen} does NOT show} the char 480 | \end{itemize} 481 | \item \mintinline{c}|getche()| 482 | \begin{itemize} 483 | \item 484 | Read char \textbf{\color{Orange} without Enter}, 485 | \textbf{\color{LimeGreen} shows} the char 486 | \end{itemize} 487 | \end{itemize} 488 | \end{frame} 489 | 490 | \begin{frame}[fragile] 491 | \frametitle{Reading Strings} 492 | \begin{itemize} 493 | \item How to read a line 494 | \item Contains spaces (read until end of line) 495 | \item \mint{c}|gets(s)| 496 | \end{itemize} 497 | \begin{minted}[bgcolor=Black]{c} 498 | char str[20]; 499 | gets(str); 500 | \end{minted} 501 | \begin{minted}[bgcolor=Black]{output} 502 | Input: ABC DEF -> str = "ABC DEF" 503 | \end{minted} 504 | \end{frame} 505 | 506 | \begin{frame}[fragile] 507 | \frametitle{Field length in scanf} 508 | \begin{itemize} 509 | \item 510 | Field length specifies the \textbf{\color{Orange} maximum} number 511 | of input characters (in the buffer) used for scanning 512 | 513 | \end{itemize} 514 | \begin{minted}[bgcolor=Black]{c} 515 | int i, j; 516 | 517 | scanf("%5d", &i); 518 | // Input: 122 -> i = 122 519 | // Input: 1234567 -> i = 12345 520 | 521 | scanf("%5d%d", &i, &j); 522 | // Input: 1 2 -> i = 1, j = 2 523 | // Input: 1234567 -> i = 12345, j = 67 524 | // Input: 123456 7 -> i = 12345, j = 6 525 | \end{minted} 526 | \end{frame} 527 | 528 | \begin{frame}[fragile] 529 | \frametitle{Special input format} 530 | \begin{itemize} 531 | \item If input data has special format with extra characters 532 | \item scanf can ignore them 533 | \end{itemize} 534 | \begin{minted}[bgcolor=Black]{c} 535 | int y, m, d; 536 | scanf("%d/%d/%d", &y, &m, &d); 537 | \end{minted} 538 | \begin{minted}[bgcolor=Black]{output} 539 | Input: 1389/12/1 -> y = 1389, m = 12, d = 1 540 | \end{minted} 541 | \end{frame} 542 | 543 | \begin{frame}[fragile] 544 | \frametitle{Format of actual input data} 545 | \begin{itemize} 546 | \item 547 | The format of actual input data \textsc{\color{YellowOrange} must} match 548 | with the format of scanf 549 | 550 | \end{itemize} 551 | \begin{minted}[bgcolor=Black]{c} 552 | int a, b; 553 | float f; 554 | scanf("%d--%d%f", &a, &b, &f); 555 | \end{minted} 556 | \begin{minted}[bgcolor=Black]{output} 557 | Input: 1--2 3.0 -> a = 1, b = 2, f = 3.0 558 | Input: 1-2 3.0 -> a = 1, b = 57, f = 0.0 559 | Input: 1.0--2 3.0 -> a = 1, b = 57, f = 0.0 560 | \end{minted} 561 | \end{frame} 562 | 563 | \section{Common Bugs} 564 | 565 | \begin{frame}[fragile] 566 | \frametitle{Common Bugs} 567 | \begin{itemize} 568 | \item Casting in printf or scanf 569 | \begin{itemize} 570 | \item \mint{c}|printf("%d", 120.23);| 571 | \item \mint{c}|double d; scanf("%f", &d);| 572 | \end{itemize} 573 | \item Mismatch between format and the number of expressions 574 | \begin{itemize} 575 | \item \mint{c}|printf("%d %d", 10);| 576 | \item \mint{c}|printf("%d", 10, 20);| 577 | \end{itemize} 578 | \item 579 | Using name of variable instead of \textbf{\color{Orange} address} 580 | \begin{itemize} 581 | \item \mint{c}|scanf("%d", i);| 582 | \end{itemize} 583 | \end{itemize} 584 | \end{frame} 585 | 586 | \begin{frame} 587 | \frametitle{Legends} 588 | \begin{figure} 589 | \includegraphics[height=.75\textheight]{./img/ghodsi.jpg} 590 | \end{figure} 591 | \pause% 592 | \centering 593 | \color{Violet} Mohammad Ghodsi 594 | \end{frame} 595 | 596 | \begin{frame} 597 | \frametitle{Legends} 598 | \begin{itemize} 599 | \item an Iranian computer scientist 600 | \item project director of FarsiTeX, a Persian typesetting language derived from TeX 601 | \item team leader for the Iranian national team participating in the International Olympiad in Informatics for several years 602 | \end{itemize} 603 | \end{frame} 604 | 605 | \end{document} 606 | -------------------------------------------------------------------------------- /lecture-5/src/pi.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int precision = 0; 6 | 7 | scanf("%d", &precision); 8 | 9 | printf("%.*lf\n", precision, M_PI); 10 | } 11 | -------------------------------------------------------------------------------- /lecture-5/src/read-with-whitespaces.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int d1; 5 | int d2; 6 | char c1; 7 | char c2; 8 | 9 | scanf("%d %c%d", &d1, &c1, &d2); 10 | scanf("\n%c", &c2); 11 | 12 | printf( 13 | "d1 = %d, d2 = %d, c1 = \"%c\", c2 = \"%c\"\n", 14 | d1, d2, c1, c2); 15 | } 16 | -------------------------------------------------------------------------------- /lecture-6/img/c-precedence.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-6/img/c-precedence.png -------------------------------------------------------------------------------- /lecture-6/img/coronavirus.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-6/img/coronavirus.jpg -------------------------------------------------------------------------------- /lecture-6/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-6/main.tex: -------------------------------------------------------------------------------- 1 | \documentclass{../c-lecture} 2 | 3 | \subtitle{Making Decisions} 4 | 5 | \begin{document} 6 | 7 | \begin{frame} 8 | \titlepage{} 9 | \end{frame} 10 | \begin{frame} 11 | \frametitle{Outline} 12 | \tableofcontents{} 13 | \end{frame} 14 | 15 | \section{Conditions and Boolean operations} 16 | 17 | \begin{frame} 18 | \frametitle{Decision} 19 | \begin{itemize} 20 | \item Decisions are based on conditions 21 | \begin{itemize} 22 | \item If it is snowing 23 | then We will cancel the game 24 | \item If the class is not canceled 25 | then I will attend 26 | else I will go to gym 27 | \end{itemize} 28 | \item In programming 29 | \begin{itemize} 30 | \item Do statements based on conditions 31 | \begin{itemize} 32 | \item \textbf{\color{LimeGreen} True}: The statements will be done 33 | \item \textbf{\color{RubineRed} False}: The statements won't be done 34 | \end{itemize} 35 | \end{itemize} 36 | \end{itemize} 37 | \end{frame} 38 | 39 | \begin{frame} 40 | \frametitle{Conditions} 41 | \begin{itemize} 42 | \item Conditions by comparisons; e.g., 43 | \begin{itemize} 44 | \item Weather vs.\ snowing 45 | \item Variable x vs.\ a value 46 | \end{itemize} 47 | \item Comparing numbers: Relational Operators 48 | \end{itemize} 49 | \end{frame} 50 | 51 | \begin{frame} 52 | \frametitle{Conditions} 53 | \begin{table} 54 | \begin{tabular}{cc} 55 | \toprule 56 | 57 | Relational Operator & 58 | Meaning \\ 59 | 60 | \midrule 61 | 62 | $<$ & 63 | is less than \\ 64 | 65 | \midrule 66 | 67 | $<=$ & 68 | is less than or equal to \\ 69 | 70 | \midrule 71 | 72 | $>$ & 73 | is greater than \\ 74 | 75 | \midrule 76 | 77 | $>=$ & 78 | is greater than or equal to \\ 79 | 80 | \midrule 81 | 82 | $==$ & 83 | is equal to \\ 84 | 85 | \midrule 86 | 87 | $!=$ & 88 | is not equal to \\ 89 | 90 | \bottomrule 91 | \end{tabular} 92 | \end{table} 93 | \end{frame} 94 | 95 | \begin{frame}[fragile] 96 | \frametitle{Relations} 97 | \begin{itemize} 98 | \item Relations are not a complete statement 99 | \begin{minted}[bgcolor=Black]{c} 100 | int a, b; 101 | a == b; // statement with no effect 102 | a <= b; // statement with no effect 103 | \end{minted} 104 | \item Relations produce a boolean value 105 | \begin{minted}[bgcolor=Black]{c} 106 | int a, b; 107 | bool bl; // #include 108 | bl = a == b; 109 | bl = a <= b; 110 | \end{minted} 111 | \end{itemize} 112 | \end{frame} 113 | 114 | \begin{frame} 115 | \frametitle{Boolean operations} 116 | \begin{itemize} 117 | \item Multiple conditions in decision making 118 | \item Logical relation between conditions 119 | \begin{itemize} 120 | \item 121 | \textmd{\color{LimeGreen} if} you are student 122 | \textmd{\color{YellowOrange} and} you have the programming course 123 | \textmd{\color{Turquoise} then} You should read the book 124 | \end{itemize} 125 | \end{itemize} 126 | \end{frame} 127 | 128 | \begin{frame}[fragile] 129 | \frametitle{Boolean operations} 130 | \begin{itemize} 131 | \item and \&\& 132 | \item or || 133 | \item not ! 134 | \end{itemize} 135 | \begin{table} 136 | \begin{tabular}{c c c c c} 137 | \toprule 138 | 139 | \mintinline{c}|p| & 140 | \mintinline{c}|q| & 141 | \mintinline{c}|p && q| & 142 | \mintinline{c}{p || q} & 143 | \mintinline{c}|!p| \\ 144 | 145 | \midrule 146 | 147 | False & 148 | False & 149 | False & 150 | False & 151 | True \\ 152 | 153 | \midrule 154 | 155 | False & 156 | True & 157 | False & 158 | True & 159 | True \\ 160 | 161 | \midrule 162 | 163 | True & 164 | False & 165 | False & 166 | True & 167 | False \\ 168 | 169 | \midrule 170 | 171 | True & 172 | True & 173 | True & 174 | True & 175 | False \\ 176 | 177 | \bottomrule 178 | \end{tabular} 179 | \end{table} 180 | \end{frame} 181 | 182 | \begin{frame}[fragile] 183 | \frametitle{Boolean operations (cont’d)} 184 | \begin{itemize} 185 | \item Examples 186 | \end{itemize} 187 | \begin{minted}[bgcolor=Black]{c} 188 | bool a = true, b = false, c; 189 | c = !a; // c = false 190 | c = a && b; // c = false 191 | c = a || b; // c = true 192 | c = !a || b; // c = false 193 | \end{minted} 194 | \end{frame} 195 | 196 | \begin{frame} 197 | \frametitle{Precedence} 198 | \begin{figure} 199 | \includegraphics[width=.75\textwidth]{img/c-precedence.png} 200 | \end{figure} 201 | \end{frame} 202 | 203 | \begin{frame}[fragile] 204 | \frametitle{Relations, No type effect} 205 | \begin{itemize} 206 | \item Usual arithmetic conversions are performed on both operands following the 207 | rules for arithmetic operators. 208 | \item The values are compared \textbf{\color{Orange} after conversions}. 209 | \end{itemize} 210 | \begin{minted}[bgcolor=Black]{c} 211 | int a = 10, b = 20; 212 | float f = 54.677f; 213 | double d = 547.775; 214 | char c1 = 'A', c2 = 'a'; 215 | bool b1; 216 | 217 | b1 = a == f; // false 218 | b1 = a <= d + 5; // true 219 | b1 = d < c1 * 10; // true 220 | b1 = c1 == c2; // false 221 | b1 = '1' < '2'; // true 222 | b1 = c1 + f < d + a; // true 223 | \end{minted} 224 | \end{frame} 225 | 226 | \begin{frame} 227 | \frametitle{Boolean in Action} 228 | \inputminted[bgcolor=Black]{c}{./src/boolean.c} 229 | \end{frame} 230 | 231 | \begin{frame}[fragile] 232 | \frametitle{Casting} 233 | \begin{itemize} 234 | \item In logical operations 235 | \begin{itemize} 236 | \item 0: False 237 | \item non-zero: True 238 | \end{itemize} 239 | \item In mathematical \& comparison operations 240 | \begin{itemize} 241 | \item False: 0 242 | \item True: 1 243 | \end{itemize} 244 | \end{itemize} 245 | \begin{minted}[bgcolor=Black]{c} 246 | bool b1, b2; 247 | int i = 0, j = 20; 248 | b1 = i && j; // b1 = false 249 | b2 = j || j; // b2 = true 250 | i = b1 + b2; // i = 1 251 | j = (i < j) + (b1 && b2); // j = 1 252 | \end{minted} 253 | \end{frame} 254 | 255 | \begin{frame}[fragile] 256 | \frametitle{Examples} 257 | \begin{itemize} 258 | \item x in [10, 20] 259 | \item \textbf{\color{RubineRed} Wrong Version} 260 | \begin{itemize} 261 | \item \mint{c}|10 <= x <= 20| 262 | \item \mint{c}|x = 30| 263 | \begin{enumerate} 264 | \item \mint{c}|10 <= 30 <= 20| 265 | \item \mint{c}|(10 <= 30) <= 20| 266 | \item \mint{c}|true <= 20| 267 | \item \mint{c}|1 <= 20| 268 | \item \mint{c}|true| 269 | \end{enumerate} 270 | \end{itemize} 271 | \end{itemize} 272 | \end{frame} 273 | 274 | \begin{frame}[fragile] 275 | \frametitle{Examples} 276 | \begin{itemize} 277 | \item x in [10, 20] 278 | \item \textbf{\color{LimeGreen} Correct Version} 279 | \begin{itemize} 280 | \item \mint{c}|(10 <= x) && (x <= 20)| 281 | \item \mint{c}|x = 30| 282 | \begin{enumerate} 283 | \item \mint{c}|(10 <= 30) && (30 <= 20)| 284 | \item \mint{c}|true && false| 285 | \item \mint{c}|false| 286 | \end{enumerate} 287 | \end{itemize} 288 | \end{itemize} 289 | \end{frame} 290 | 291 | \begin{frame}[fragile] 292 | \frametitle{Examples} 293 | \begin{itemize} 294 | \item a, b > 0 295 | \item \textbf{\color{RubineRed} Wrong Version} 296 | \begin{itemize} 297 | \item \mint{c}|a && b > 0| 298 | \item \mint{c}|a = -10; b = 20| 299 | \begin{enumerate} 300 | \item \mint{c}|-10 && 20 > 0| 301 | \item \mint{c}|-10 && (20 > 0)| 302 | \item \mint{c}|-10 && true| 303 | \item \mint{c}|true && true| 304 | \item \mint{c}|true| 305 | \end{enumerate} 306 | \end{itemize} 307 | \end{itemize} 308 | \end{frame} 309 | 310 | \begin{frame}[fragile] 311 | \frametitle{Examples} 312 | \begin{itemize} 313 | \item a, b > 0 314 | \item \textbf{\color{LimeGreen} Correct Version} 315 | \begin{itemize} 316 | \item \mint{c}|(a > 0) && (b > 0)| 317 | \item \mint{c}|a = -10; b = 20| 318 | \begin{enumerate} 319 | \item \mint{c}|(-10 > 0) && (20 > 0)| 320 | \item \mint{c}|false && true| 321 | \item \mint{c}|false| 322 | \end{enumerate} 323 | \end{itemize} 324 | \end{itemize} 325 | \end{frame} 326 | 327 | \section{if-else statement} 328 | 329 | \begin{frame}[fragile] 330 | \frametitle{Type of statements} 331 | \begin{itemize} 332 | \item Expression statement 333 | \begin{itemize} 334 | \item Single statements 335 | \end{itemize} 336 | \begin{minted}[bgcolor=Black]{c} 337 | x = y + 10; 338 | scanf("%d", &i); 339 | \end{minted} 340 | \item Control statement 341 | \begin{itemize} 342 | \item Control the flow of program 343 | \item Decisions and loops 344 | \end{itemize} 345 | \item Compound statement 346 | \begin{itemize} 347 | \item Starts with \{ and ends with \} 348 | \item All statements can be between \{ and \} 349 | \end{itemize} 350 | \end{itemize} 351 | \end{frame} 352 | 353 | \begin{frame}[fragile] 354 | \frametitle{if statement} 355 | \begin{itemize} 356 | \item Decision making in C 357 | \begin{minted}[bgcolor=Black]{c} 358 | if ( ) 359 | ; 360 | else 361 | ; 362 | \end{minted} 363 | \item Expression 364 | \begin{itemize} 365 | \item A boolean statement: \mint{c}|a <= b| 366 | \item 367 | A mathematical statement: \mint{c}|a + b| or a variable: \mint{c}|a| 368 | \begin{itemize} 369 | \item zero means false 370 | \item non-zero means true 371 | \end{itemize} 372 | \end{itemize} 373 | \end{itemize} 374 | \end{frame} 375 | 376 | \begin{frame}[fragile] 377 | \frametitle{Even-Odd} 378 | \begin{minted}[bgcolor=Black]{c} 379 | #include 380 | int main(void) { 381 | int number_to_test, remainder; 382 | printf("Enter your number to be tested: "); 383 | scanf("%d", &number_to_test); 384 | remainder = number_to_test % 2; 385 | if(remainder == 0) 386 | printf ("The number is even.\n"); 387 | else 388 | printf ("The number is odd.\n"); 389 | return 0; 390 | } 391 | \end{minted} 392 | \end{frame} 393 | 394 | \begin{frame}[fragile] 395 | \frametitle{Statements in if-else} 396 | \begin{itemize} 397 | \item Empty statement 398 | \begin{minted}[bgcolor=Black]{c} 399 | if (a < b) 400 | printf("A is larger than b\n"); 401 | else 402 | ; 403 | \end{minted} 404 | \item Block statements 405 | \begin{minted}[bgcolor=Black]{c} 406 | if (a <= b) { 407 | printf("A is less than b or "); 408 | printf("A is equal b\n"); 409 | } 410 | else 411 | printf("A is greater than b\n"); 412 | \end{minted} 413 | \end{itemize} 414 | \end{frame} 415 | 416 | \begin{frame}[fragile] 417 | \frametitle{Statements in if-else} 418 | \scriptsize 419 | \begin{minted}[bgcolor=Black]{c} 420 | #include 421 | 422 | int main(void) { 423 | int i; 424 | char c; 425 | 426 | printf("Enter a char: "); 427 | scanf(" %c", &c); 428 | 429 | printf("Enter an int: "); 430 | scanf("%d", &i); 431 | 432 | if (i > 0) 433 | printf("Your number is larger than 0\n"); 434 | else 435 | printf("Your number is less than or equal 0\n"); 436 | 437 | if ((c >= '0') && (c <= '9')) 438 | printf("Your char is Numeric \n"); 439 | 440 | return 0; 441 | } 442 | \end{minted} 443 | \end{frame} 444 | 445 | \begin{frame} 446 | \frametitle{More than two choices} 447 | \begin{itemize} 448 | \item If statement: 2 choices 449 | \begin{itemize} 450 | \item If conditions are true will run if statements 451 | \item If conditions are false will run else statements 452 | \end{itemize} 453 | \item How to make decisions when there are multiple choices? 454 | \end{itemize} 455 | \end{frame} 456 | 457 | \begin{frame}[fragile] 458 | \frametitle{Map numeric grade to alphabetic} 459 | \begin{minted}[bgcolor=Black]{c} 460 | int numg; 461 | char alphag; 462 | if(numg < 25) 463 | alphag = 'D'; 464 | if((numg >= 25) && (numg < 50)) 465 | alphag = 'C'; 466 | if((numg >= 50) && (numg < 75)) 467 | alphag = 'B'; 468 | if(numg >= 75) 469 | alphag = 'A'; 470 | \end{minted} 471 | \end{frame} 472 | 473 | \begin{frame} 474 | \frametitle{More than two choices} 475 | \begin{itemize} 476 | \item To avoid repeating conditions in if statements 477 | \item To avoid running unnecessary statements 478 | \item \textbf{\color{RubineRed} Nested} if: check multiple conditions 479 | \begin{itemize} 480 | \item \mintinline{c}|| becomes an if-else statement 481 | \item \mintinline{c}|| becomes an if-else statement 482 | \item Repeat it as many as needed 483 | \end{itemize} 484 | \end{itemize} 485 | \end{frame} 486 | 487 | \begin{frame}[fragile] 488 | \frametitle{Nested if-else} 489 | \scriptsize 490 | \begin{minted}[bgcolor=Black]{c} 491 | if (c1 && c2) 492 | s1 493 | if (c1 && !(c2)) 494 | s2 495 | if (!(c1) && c3) 496 | s3 497 | if (!(c1) && !(c3)) 498 | s4 499 | \end{minted} 500 | \scriptsize 501 | \begin{minted}[bgcolor=Black]{c} 502 | if (c1) 503 | if (c2) 504 | s1 505 | else 506 | s2 507 | else 508 | if (c3) 509 | s3 510 | else 511 | s4 512 | \end{minted} 513 | \end{frame} 514 | 515 | \begin{frame}[fragile] 516 | \frametitle{Map numeric grade to alphabetic} 517 | \scriptsize 518 | \begin{minted}[bgcolor=Black]{c} 519 | int numg; 520 | char alphag; 521 | 522 | if (numg < 25) 523 | alphag = ‘D’; 524 | else { 525 | if (numg < 50) 526 | alphag = ‘C’; 527 | else { 528 | if (numg < 75) 529 | alphag = ‘B’; 530 | else 531 | alphag = ‘A’; 532 | } 533 | } 534 | \end{minted} 535 | \end{frame} 536 | 537 | \begin{frame}[fragile] 538 | \frametitle{Nested if-else} 539 | \scriptsize 540 | \begin{minted}[bgcolor=Black]{c} 541 | if () 542 | 543 | else { 544 | if () 545 | 546 | else 547 | 548 | } 549 | \end{minted} 550 | \scriptsize 551 | \begin{minted}[bgcolor=Black]{c} 552 | if () 553 | 554 | else if () 555 | 556 | else 557 | 558 | \end{minted} 559 | \end{frame} 560 | 561 | \begin{frame}[fragile] 562 | \frametitle{Map numeric grade to alphabetic} 563 | \begin{minted}[bgcolor=Black]{c} 564 | int numg; 565 | char alphag; 566 | 567 | if(numg < 25) 568 | alphag = 'D'; 569 | else if(numg < 50) 570 | alphag = 'C'; 571 | else if(numg < 75) 572 | alphag = 'B'; 573 | else 574 | alphag = 'A'; 575 | \end{minted} 576 | \end{frame} 577 | 578 | \begin{frame}[fragile] 579 | \frametitle{Nested if: Incomplete branch} 580 | \begin{enumerate} 581 | \item \textit{\color{Orange} else} part is optional 582 | \item 583 | \textit{\color{Orange} else} always associates with the 584 | \textit{\color{LimeGreen} nearest} 585 | \textit{\color{Orange} if} 586 | 587 | \item 1 + 2 can be dangerous specially in incomplete branchs 588 | \end{enumerate} 589 | Example: Tell user to move or game over 590 | \begin{minted}[bgcolor=Black]{c} 591 | if (gameIsOver == 0) 592 | if (playerToMove == YOU) 593 | printf ("Your Move\n"); 594 | else 595 | printf ("The game is over\n"); 596 | \end{minted} 597 | \begin{itemize} 598 | \item To avoid error you should 599 | \item Close off you code or Use Empty statements 600 | \end{itemize} 601 | \end{frame} 602 | 603 | \section{switch-case statement} 604 | 605 | \begin{frame}[fragile] 606 | \frametitle{switch-case: Multiple choices} 607 | \begin{itemize} 608 | \item Multiple conditions 609 | \begin{itemize} 610 | \item if-else if-else if-\ldots 611 | \end{itemize} 612 | \item 613 | Select from alternative \textit{\color{Orange} values} of a 614 | \textit{\color{LimeGreen} variable} 615 | 616 | \begin{itemize} 617 | \item switch-case 618 | \item 619 | Values should be \textit{\color{Orange} constant} not expression: 620 | i, i+j, 621 | 622 | \item 623 | Values \& Variables should be \textit{\color{Orange} int} or 624 | \textit{\color{Orange} char} 625 | 626 | \end{itemize} 627 | \end{itemize} 628 | \begin{minted}[bgcolor=Black]{c} 629 | switch (variable) { 630 | case value1: 631 | 632 | case value2: 633 | 634 | } 635 | \end{minted} 636 | \end{frame} 637 | 638 | \begin{frame}[fragile] 639 | \frametitle{How does switch-case work?} 640 | \begin{itemize} 641 | \item Each switch-case can be rewritten by if-else 642 | \end{itemize} 643 | \begin{minted}[bgcolor=Black]{c} 644 | if (variable == value1) { 645 | 646 | 647 | } 648 | else if (variable == value2) { 649 | 650 | } 651 | \end{minted} 652 | \end{frame} 653 | 654 | \begin{frame}[fragile] 655 | \frametitle{switch-case: complete version} 656 | \scriptsize 657 | \begin{minted}[bgcolor=Black]{c} 658 | switch(variable) { 659 | case value1: 660 | 661 | break; 662 | case value2: 663 | 664 | break; 665 | default: 666 | 667 | } 668 | \end{minted} 669 | \scriptsize 670 | \begin{minted}[bgcolor=Black]{c} 671 | if (variable == value1) { 672 | 673 | } 674 | else if (variable == value2) { 675 | 676 | } 677 | else { 678 | 679 | } 680 | \end{minted} 681 | \end{frame} 682 | 683 | \begin{frame}[fragile] 684 | \frametitle{switch-case (cont’d)} 685 | \begin{itemize} 686 | \item All values used in case should be different 687 | \end{itemize} 688 | \begin{minted}[bgcolor=Black]{c} 689 | switch(i) { // Error 690 | case 1: 691 | ... 692 | case 2: 693 | ... 694 | case 1: 695 | \end{minted} 696 | \end{frame} 697 | 698 | \begin{frame}[fragile] 699 | \frametitle{switch-case (cont’d)} 700 | \begin{itemize} 701 | \item All values must be value, not expression of variables 702 | \end{itemize} 703 | \scriptsize 704 | \begin{minted}[bgcolor=Black]{c} 705 | switch(i) { // Error 706 | case j: 707 | ... 708 | case 2: 709 | ... 710 | case k+10: 711 | \end{minted} 712 | \end{frame} 713 | 714 | \begin{frame}[fragile] 715 | \frametitle{switch-case: multiple matches} 716 | \scriptsize 717 | \begin{minted}[bgcolor=Black]{c} 718 | switch (variable) { 719 | case value1: 720 | case value2: 721 | 722 | break; 723 | case value3: 724 | 725 | } 726 | \end{minted} 727 | \scriptsize 728 | \begin{minted}[bgcolor=Black]{c} 729 | if ( 730 | (variable == value1) || 731 | (variable == value2) 732 | ){ 733 | 734 | } else if (variable == value3) { 735 | 736 | } 737 | \end{minted} 738 | \end{frame} 739 | 740 | \begin{frame}[fragile] 741 | \frametitle{switch-case vs.\ if-else} 742 | \begin{itemize} 743 | \item 744 | \textit{\color{Orange} if-else} is more powerful than 745 | \textit{\color{Orange} switch-case} 746 | 747 | \item 748 | \textit{\color{LimeGreen} switch-case} is only for checking the 749 | \textit{\color{LimeGreen} values of a variable} and the values must be 750 | \textit{\color{LimeGreen} constant} 751 | 752 | \item if-else is more suitable in some cases, e.g., 753 | \begin{minted}[bgcolor=Black]{c} 754 | double var1, var2; 755 | if (var1 <= 1.1) 756 | 757 | else if (var1 == var2) 758 | 759 | \end{minted} 760 | \end{itemize} 761 | \end{frame} 762 | 763 | \begin{frame}[fragile] 764 | \frametitle{Nested switch-case} 765 | \scriptsize 766 | \begin{minted}[bgcolor=Black]{c} 767 | bool b; // b = x && y 768 | switch (x) { 769 | case 0: 770 | b = 0; 771 | break; 772 | case 1: 773 | switch(y){ 774 | case 0: 775 | b = 0; 776 | break; 777 | case 1: 778 | b = 1; 779 | break; 780 | } 781 | break; 782 | } 783 | \end{minted} 784 | \end{frame} 785 | 786 | \section{Conditional expressions} 787 | 788 | \begin{frame}[fragile] 789 | \frametitle{Conditional Expression} 790 | \begin{itemize} 791 | \item Assign value according to conditions 792 | \item A ternary operator 793 | \end{itemize} 794 | \begin{minted}[bgcolor=Black]{c} 795 | int i, j, k; 796 | bool b; 797 | 798 | i = b ? j : k; 799 | \end{minted} 800 | \begin{minted}[bgcolor=Black]{c} 801 | if (b) 802 | i = j; 803 | else 804 | i = k; 805 | \end{minted} 806 | \end{frame} 807 | 808 | \begin{frame}[fragile] 809 | \frametitle{Conditional Expression: Examples} 810 | \begin{minted}[bgcolor=Black]{c} 811 | abs = (x > 0) ? x : -x 812 | 813 | sign = (x < 0) ? -1 : ((x > 0) ? 1 : 0) 814 | \end{minted} 815 | \end{frame} 816 | 817 | \section{Common Bugs} 818 | 819 | \begin{frame}[fragile] 820 | \frametitle{Common Bugs} 821 | \begin{itemize} 822 | \item Equality of floating point numbers 823 | \item 824 | Two float numbers may or may \textbf{\color{RubineRed} NOT} be equal 825 | \end{itemize} 826 | \scriptsize 827 | \begin{minted}[bgcolor=Black]{c} 828 | double d1, d2; 829 | d1 = 1e20 + 1; 830 | d2 = 1e20 - 1; 831 | printf("%lf\n", d1); 832 | printf("%lf\n", d2); 833 | if(d1 == d2) 834 | printf("They are equal :-o \n"); 835 | else 836 | printf("They are not equal :D \n"); 837 | \end{minted} 838 | \scriptsize 839 | \begin{minted}[bgcolor=Black]{output} 840 | 100000000000000000000.000000 841 | 100000000000000000000.000000 842 | They are equal :-o 843 | \end{minted} 844 | \end{frame} 845 | 846 | \begin{frame}[fragile] 847 | \frametitle{Avoiding Bugs} 848 | \begin{block}{} 849 | Instead of checking for equality, check their difference to be in a 850 | small-enough period. 851 | \end{block} 852 | \begin{minted}[bgcolor=Black]{c} 853 | double d1, d2; 854 | d1 = 1e20 + 1; 855 | d2 = 1e20 - 1; 856 | if(fabs(d1 - d2) <= 0.0000001) 857 | printf("They are equal :-o \n"); 858 | else 859 | printf("They are not equal :D \n"); 860 | \end{minted} 861 | \end{frame} 862 | 863 | \begin{frame}[fragile] 864 | \frametitle{Common Bugs} 865 | \begin{itemize} 866 | \item Danger of empty statement 867 | \item Danger of assignment (=) and equality (==) 868 | \begin{minted}[bgcolor=Black]{c} 869 | int a = 10; 870 | int b = 20; 871 | if (a = b) // logical but not compile error!!! 872 | \end{minted} 873 | \item Danger of similarity between C and mathematic 874 | \begin{minted}[bgcolor=Black]{c} 875 | if (a < b < c) // Logical Error 876 | if (a && b < 0) // Logical Error 877 | \end{minted} 878 | \end{itemize} 879 | \end{frame} 880 | 881 | \begin{frame} 882 | \frametitle{Avoiding Bugs} 883 | \begin{itemize} 884 | \item Precedence of operators 885 | \item Use parenthesis in conditions 886 | \item Close-off code as much as you can 887 | \end{itemize} 888 | \end{frame} 889 | 890 | \begin{frame} 891 | \frametitle{Debugging by assert} 892 | \begin{itemize} 893 | \item 894 | The assert macro is defined in \textit{\color{Orange} assert.h} 895 | \item \mint{c}|assert()| 896 | \begin{itemize} 897 | \item If the expression is true: nothing 898 | \item If the expression is false: error message + halt 899 | \end{itemize} 900 | \end{itemize} 901 | \end{frame} 902 | 903 | \begin{frame} 904 | \frametitle{Legends} 905 | \begin{figure} 906 | \includegraphics[height=.75\textheight]{./img/coronavirus.jpg} 907 | \end{figure} 908 | \pause% 909 | \centering 910 | \color{Violet} COVID-19 911 | \end{frame} 912 | 913 | \end{document} 914 | -------------------------------------------------------------------------------- /lecture-6/src/boolean.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int a = 10; 6 | float b = 10.0f; 7 | int c = 20; 8 | 9 | bool b1 = a == b; 10 | bool b2 = a == c; 11 | bool b3 = b1 && b2; 12 | 13 | printf("b1 = %d, b2 = %d, b3 = %d\n", b1, b2, b3); 14 | } 15 | -------------------------------------------------------------------------------- /lecture-7/img/nowruz.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-7/img/nowruz.jpg -------------------------------------------------------------------------------- /lecture-7/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-7/main.tex: -------------------------------------------------------------------------------- 1 | \documentclass{../c-lecture} 2 | 3 | \usepackage{algorithm2e} 4 | 5 | \subtitle{Repeating Statements} 6 | 7 | \begin{document} 8 | 9 | \begin{frame} 10 | \titlepage{} 11 | \end{frame} 12 | \begin{frame} 13 | \frametitle{Outline} 14 | \tableofcontents{} 15 | \end{frame} 16 | 17 | \section{Introduction} 18 | 19 | \begin{frame} 20 | \frametitle{Repetition} 21 | \begin{itemize} 22 | \item Example: Write a program that read 3 integer and compute average 23 | \begin{itemize} 24 | \item It is easy. 3 scanf, an addition, a division and, a printf 25 | \end{itemize} 26 | \item Example: Write a program that read 3000 integer and compute average 27 | \begin{itemize} 28 | \item 3000 scanf!!!? 29 | \end{itemize} 30 | \item Example: Write a program that read n integer and compute average 31 | \begin{itemize} 32 | \item N??? scanf 33 | \end{itemize} 34 | \end{itemize} 35 | \end{frame} 36 | 37 | \begin{frame} 38 | \frametitle{Repetition: counter controlled} 39 | \begin{itemize} 40 | \item When we know the number of iteration 41 | \begin{itemize} 42 | \item Average of 10 number 43 | \end{itemize} 44 | \end{itemize} 45 | \begin{algorithm}[H] 46 | \KwData{} 47 | \KwResult{} 48 | $counter \gets 0$\; 49 | 50 | \While{$counter < number\_of\_loop\_repetition$}{% 51 | do something (e.g.\ read input, take sum)\; 52 | $counter \gets counter + 1$\; 53 | } 54 | \end{algorithm} 55 | \end{frame} 56 | 57 | \begin{frame} 58 | \frametitle{Repetition: sentinel controlled} 59 | \begin{itemize} 60 | \item 61 | When we do \textbf{\color{RubineRed} NOT} know the number of iteration 62 | \item But we know, when loop terminates 63 | \begin{itemize} 64 | \item E.g. Average of arbitrary positive numbers ending with < 0 65 | \end{itemize} 66 | \end{itemize} 67 | \begin{algorithm}[H] 68 | \KwData{} 69 | \KwResult{} 70 | $n \gets$ get first input\; 71 | 72 | \While{$n != sentinel$}{% 73 | do something (sum, \ldots)\; 74 | $n \gets$ get the next input\; 75 | \eIf{there is not any valid input}{% 76 | S1 77 | }{% 78 | S2 79 | } 80 | } 81 | \end{algorithm} 82 | \end{frame} 83 | 84 | \begin{frame} 85 | \frametitle{Repetition} 86 | \begin{itemize} 87 | \item Repetition is performed by loops 88 | \begin{itemize} 89 | \item 90 | Put all statements to repeat in a \textbf{\color{Orange} loop} 91 | \end{itemize} 92 | \item Don’t loop to infinity 93 | \begin{itemize} 94 | \item Stop the repetition 95 | \item Based on some conditions (counter, sentinel) 96 | \end{itemize} 97 | \item C has three statements for loops 98 | \begin{itemize} 99 | \item \textit{\color{Orange} while} statement 100 | \item \textit{\color{Orange} do-while} statement 101 | \item \textit{\color{Orange} for} statement 102 | \end{itemize} 103 | \end{itemize} 104 | \end{frame} 105 | 106 | \section{while statement} 107 | 108 | \begin{frame}[fragile] 109 | \frametitle{while statement} 110 | \begin{minted}[bgcolor=Black]{c} 111 | while ( ) 112 | 113 | \end{minted} 114 | \end{frame} 115 | 116 | \begin{frame}[fragile] 117 | \frametitle{print 0 to n} 118 | \begin{minted}[bgcolor=Black]{c} 119 | #include 120 | 121 | int main(void) { 122 | int n, number; 123 | number = 0; 124 | printf("Enter n: "); 125 | scanf("%d", &n); 126 | while(number <= n) { 127 | printf("%d \n", number); 128 | number++; 129 | } 130 | return 0; 131 | } 132 | \end{minted} 133 | \end{frame} 134 | 135 | \section{do-while statement} 136 | 137 | \begin{frame}[fragile] 138 | \frametitle{do-while statement} 139 | \begin{minted}[bgcolor=Black]{c} 140 | do { 141 | 142 | } while ( ); 143 | \end{minted} 144 | \end{frame} 145 | 146 | \begin{frame}[fragile] 147 | \frametitle{sum of the n term: 1/2 + 2/3 \ldots} 148 | \scriptsize 149 | \begin{minted}[bgcolor=Black]{c} 150 | #include 151 | 152 | int main(void) { 153 | int n; 154 | double number, sum; 155 | 156 | printf("Enter n > 0: "); 157 | scanf("%d", &n); 158 | 159 | if(n < 1){ 160 | printf("wrong input"); 161 | return -1; 162 | } 163 | 164 | sum = 0; 165 | number = 0.0; 166 | do { 167 | number++; 168 | sum += number / (number + 1.0); 169 | } while(number < n); 170 | 171 | printf("sum = %lf\n", sum); 172 | return 0; 173 | } 174 | \end{minted} 175 | \end{frame} 176 | 177 | \begin{frame}[fragile] 178 | \frametitle{sum of the inputs until zeor} 179 | \scriptsize 180 | \inputminted[bgcolor=Black]{c}{./src/do-while-read.c} 181 | \end{frame} 182 | 183 | \section{for statement} 184 | 185 | \begin{frame}[fragile] 186 | \frametitle{for statement} 187 | \begin{minted}[bgcolor=Black]{c} 188 | for(; ; ) 189 | 190 | \end{minted} 191 | \end{frame} 192 | 193 | \begin{frame} 194 | \frametitle{for statement} 195 | \begin{enumerate} 196 | \item The delaration, definition, and initialization of the \textbf{loop variable(s)} 197 | \item A \textbf{loop condition} which specifies how long the for iteration should continue. 198 | \begin{itemize} 199 | \item The loop condition is checked before each execution of the loop body. 200 | \end{itemize} 201 | \item Another statement which is executed after each iteration. 202 | \end{enumerate} 203 | \end{frame} 204 | 205 | \begin{frame}[fragile] 206 | \frametitle{N students average grade} 207 | \scriptsize 208 | \begin{minted}[bgcolor=Black]{c} 209 | #include 210 | 211 | int main(void) { 212 | int grade, count, i; 213 | double average, sum; 214 | sum = 0; 215 | printf("Enter the number of students: "); 216 | scanf("%d", &count); 217 | for(i = 0; i < count; i++) { 218 | printf("Enter the grade of %d-th student: ", (i + 1)); 219 | scanf("%d", &grade); 220 | sum += grade; 221 | } 222 | average = sum / count; 223 | printf("The average of your class is %0.3lf\n", average); 224 | return 0; 225 | } 226 | \end{minted} 227 | \end{frame} 228 | 229 | \begin{frame}[fragile] 230 | \frametitle{Expressions in for statements} 231 | \begin{itemize} 232 | \item 233 | Expression1 and Expression3 can be any number of expressions, they execute 234 | in the order 235 | \begin{minted}[bgcolor=Black]{c} 236 | for(i = 0, j = 0; i < 10; i++, j--) 237 | \end{minted} 238 | \item Expression2 at most should be a single expression 239 | \item 240 | If multiple expressions then the value of the last one is evaluated as 241 | True/False 242 | \begin{minted}[bgcolor=Black]{c} 243 | for(i = 0, j = 0; i < 10, j > -100; i++, j--) 244 | \end{minted} 245 | \end{itemize} 246 | \end{frame} 247 | 248 | \begin{frame}[fragile] 249 | \frametitle{Expressions in for statements} 250 | \begin{itemize} 251 | \item Any expression can be empty expression 252 | \begin{minted}[bgcolor=Black]{c} 253 | for( ; i < 10; i++) 254 | for(;;) 255 | \end{minted} 256 | \end{itemize} 257 | \end{frame} 258 | 259 | \begin{frame}[fragile] 260 | \frametitle{Loop Variable} 261 | \begin{itemize} 262 | \item 263 | Often, people place the definition of the loop variable somewhere before the for or even 264 | reuse variable for several loops. 265 | \item \textsc{\color{RubineRed} Don't} do that. 266 | \item to help occasional reader and the compiler understand your code 267 | \item it is important to know that this variable has the special meaning of an iteration counter for that given for loop 268 | \end{itemize} 269 | \begin{minted}[bgcolor=Black]{c} 270 | for(int i = 0; i < 10; i++) 271 | \end{minted} 272 | \end{frame} 273 | 274 | \section{Arrays} 275 | 276 | \begin{frame} 277 | \frametitle{Introduction} 278 | \begin{itemize} 279 | \item Algorithms usually work on large data sets 280 | \begin{itemize} 281 | \item Sort a set of numbers 282 | \item Search a specific number in a set of numbers 283 | \end{itemize} 284 | \item How to read and store a set of data? 285 | \item To Read 286 | \begin{itemize} 287 | \item Repeat the \textit{scanf} statement 288 | \item Use the loop statements 289 | \end{itemize} 290 | \item To store the data 291 | \begin{itemize} 292 | \item Save each data in a single variable?? 293 | \item 3000 int variables!!!! 294 | \end{itemize} 295 | \end{itemize} 296 | \end{frame} 297 | 298 | \begin{frame} 299 | \frametitle{Array} 300 | \begin{itemize} 301 | \item 302 | An \textit{\color{Orange} ordered} collection of 303 | \textit{\color{Orange} same type} variables 304 | 305 | \item A $1 x n$ vector of 306 | \begin{itemize} 307 | \item Integers, chars, floats, \ldots 308 | \end{itemize} 309 | \item Example 310 | \begin{itemize} 311 | \item An array of 8 integers 312 | \begin{table} 313 | \begin{tabular}{*{8}{c}} 314 | \toprule 315 | 316 | 0 & 317 | 1 & 318 | 2 & 319 | 3 & 320 | 4 & 321 | 5 & 322 | 6 & 323 | 7 \\ 324 | 325 | \midrule 326 | 327 | 3 & 328 | 1 & 329 | 5 & 330 | 11 & 331 | 10 & 332 | 19 & 333 | 0 & 334 | 12 \\ 335 | 336 | \bottomrule 337 | \end{tabular} 338 | \end{table} 339 | \item An array of 5 chars 340 | \begin{table} 341 | \begin{tabular}{*{5}{c}} 342 | \toprule 343 | 344 | 0 & 345 | 1 & 346 | 2 & 347 | 3 & 348 | 4 \\ 349 | 350 | \midrule 351 | 352 | a & 353 | z & 354 | F & 355 | z & 356 | k \\ 357 | 358 | \bottomrule 359 | \end{tabular} 360 | \end{table} 361 | \end{itemize} 362 | \end{itemize} 363 | \end{frame} 364 | 365 | \begin{frame}[fragile] 366 | \frametitle{Arrays in C} 367 | \begin{itemize} 368 | \item Array declaration in C 369 | \begin{minted}[bgcolor=Black]{c} 370 | [] 371 | \end{minted} 372 | \begin{minted}[bgcolor=Black]{c} 373 | int arr[20] 374 | \end{minted} 375 | \item 376 | \mintinline{c}||: int, char, float, 377 | \ldots 378 | \item \mintinline{c}|| 379 | \begin{itemize} 380 | \item Old compilers (standard): it should be constant 381 | \item New compilers (standard): it can be variable 382 | \end{itemize} 383 | \item Elements in array 384 | \begin{itemize} 385 | \item From 0 to (size – 1) 386 | \end{itemize} 387 | \end{itemize} 388 | \end{frame} 389 | 390 | \begin{frame}[fragile] 391 | \frametitle{Example} 392 | \begin{minted}[bgcolor=Black]{c} 393 | int num[20] 394 | \end{minted} 395 | \begin{itemize} 396 | \item num is array of 20 integers 397 | \item num[0] is the first integer variable 398 | \item num[19] is the last integer 399 | \end{itemize} 400 | \begin{minted}[bgcolor=Black]{c} 401 | float farr[100] 402 | \end{minted} 403 | \begin{itemize} 404 | \item farr is array of 100 floats 405 | \item farr[0] is the first float 406 | \item farr[49] is the 50th float 407 | \item farr[99] is the last float 408 | \end{itemize} 409 | \end{frame} 410 | 411 | \begin{frame}[fragile] 412 | \frametitle{Array Initialization: Known Length} 413 | \begin{itemize} 414 | \item \mint{c}|int num[3]={10, 20, 60};| 415 | \begin{itemize} 416 | \item num is the array of 3 integers, \mintinline{c}|num[0]| is 10, \ldots 417 | \end{itemize} 418 | 419 | \item \mint{c}|int num[]={40, 50, 60, 70, 70, 80};| 420 | \begin{itemize} 421 | \item num is the array of 6 integers 422 | \end{itemize} 423 | 424 | \item \mint{c}|int num[10]={40, 50, 60};| 425 | \begin{itemize} 426 | \item num is the array of 10 integers 427 | \item \mintinline{c}|num[0]| is 40, \mintinline{c}|num[1]| is 50, \mintinline{c}|num[2]| is 60 428 | \item \mintinline{c}|num[3], num[4], ..., num[9]| are 0 429 | \end{itemize} 430 | \end{itemize} 431 | \end{frame} 432 | 433 | \begin{frame}[fragile] 434 | \frametitle{Array Initialization (cont’d)} 435 | \begin{minted}[bgcolor=Black]{c} 436 | int num[2]={40, 50, 60, 70}; 437 | /* Compile warning */ 438 | 439 | int num[5]={[0] = 3, [4] = 6}; 440 | /* num[5] = {3, 0, 0, 0, 6} */ 441 | \end{minted} 442 | \end{frame} 443 | 444 | \begin{frame}[fragile] 445 | \frametitle{Array Initialization (cont’d)} 446 | \inputminted[bgcolor=Black]{c}{./src/init_with_zero.c} 447 | \end{frame} 448 | 449 | \begin{frame}[fragile] 450 | \frametitle{Initializing Variable Length Arrays} 451 | \begin{minted}[bgcolor=Black]{c} 452 | int n; 453 | scanf("%d", &n); 454 | int num[n]={0}; /* Compile error */ 455 | \end{minted} 456 | \begin{block}{} 457 | Variable length arrays cannot be initialized! 458 | \end{block} 459 | \begin{minted}[bgcolor=Black]{c} 460 | for(i = 0; i < n; i++) 461 | num[i] = 0; 462 | \end{minted} 463 | \end{frame} 464 | 465 | \begin{frame}[fragile] 466 | \frametitle{Variable Length Array Declaration} 467 | \begin{minted}[bgcolor=Black]{c} 468 | int n; 469 | scanf("%d", &n); 470 | int num[n]; 471 | \end{minted} 472 | \begin{block}{} 473 | \textit{\color{Orange} num} is usable 474 | \end{block} 475 | \begin{minted}[bgcolor=Black]{c} 476 | int n; 477 | int num[n]; 478 | scanf("%d", &n); 479 | \end{minted} 480 | \begin{block}{} 481 | \textit{\color{Orange} num} is 482 | \textit{\color{RubineRed} not} usable, why? 483 | \end{block} 484 | \end{frame} 485 | 486 | \section{Advanced loops} 487 | 488 | \begin{frame}[fragile] 489 | \frametitle{Empty statements} 490 | \begin{itemize} 491 | \item in loops can be empty 492 | \end{itemize} 493 | \begin{minted}[bgcolor=Black]{c} 494 | while() ; 495 | \end{minted} 496 | e.g., 497 | \begin{minted}[bgcolor=Black]{c} 498 | while(i++ <= n) ; 499 | \end{minted} 500 | 501 | \begin{minted}[bgcolor=Black]{c} 502 | for(; ; ) ; 503 | \end{minted} 504 | e.g., 505 | \begin{minted}[bgcolor=Black]{c} 506 | for(i = 0; i < 10; printf("%d\n",i), i++) ; 507 | \end{minted} 508 | \end{frame} 509 | 510 | \begin{frame}[fragile] 511 | \frametitle{Nested loops} 512 | \begin{itemize} 513 | \item in loops can be loop itself 514 | \end{itemize} 515 | \begin{minted}[bgcolor=Black]{c} 516 | while() 517 | for(; ; ) 518 | 519 | \end{minted} 520 | \begin{minted}[bgcolor=Black]{c} 521 | for(; ; ) 522 | do 523 | 524 | while() 525 | \end{minted} 526 | \end{frame} 527 | 528 | \begin{frame}[fragile] 529 | \frametitle{Nested loops example} 530 | \begin{itemize} 531 | \item A program that takes n and m and prints 532 | \begin{minted}[bgcolor=Black]{output} 533 | *** ...* (m * in each line) 534 | *** ...* 535 | ... 536 | *** ...* 537 | (n lines) 538 | \end{minted} 539 | \end{itemize} 540 | \end{frame} 541 | 542 | \begin{frame}[fragile] 543 | \begin{minted}[bgcolor=Black]{c} 544 | #include 545 | 546 | int main(void){ 547 | int i, j, n, m; 548 | printf("Enter n & m: "); 549 | scanf("%d %d", &n, &m); 550 | 551 | for(i = 0; i < n; i++){ 552 | for(j = 0; j < m; j++) { 553 | printf("*"); 554 | } 555 | printf("\n"); 556 | } 557 | return 0; 558 | } 559 | \end{minted} 560 | \end{frame} 561 | 562 | \begin{frame}[fragile] 563 | \frametitle{Nested loops example} 564 | \begin{itemize} 565 | \item A program that takes n and prints 566 | \begin{minted}[bgcolor=Black]{output} 567 | * (i * in i-th line) 568 | ** 569 | *** 570 | *** ...* 571 | (n lines) 572 | \end{minted} 573 | \end{itemize} 574 | \end{frame} 575 | 576 | \begin{frame}[fragile] 577 | \begin{minted}[bgcolor=Black]{c} 578 | #include 579 | 580 | int main(void) { 581 | int i, j, n; 582 | printf("Enter n: "); 583 | scanf("%d", &n); 584 | 585 | i = 1; 586 | while(i <= n) { 587 | for(j = 0; j < i; j++) { 588 | printf("*"); 589 | } 590 | printf("\n"); 591 | i++; 592 | } 593 | return 0; 594 | } 595 | \end{minted} 596 | \end{frame} 597 | 598 | \begin{frame}[fragile] 599 | \frametitle{break statement} 600 | \begin{itemize} 601 | \item Exit from loop based on some conditions 602 | \end{itemize} 603 | \begin{minted}[bgcolor=Black]{c} 604 | do{ 605 | scanf("%d", &a); 606 | scanf("%d", &b); 607 | 608 | if(b == 0) 609 | break; 610 | 611 | res = a / b; 612 | printf("a / b = %d\n", res); 613 | } while(b > 0); 614 | \end{minted} 615 | \end{frame} 616 | 617 | \begin{frame}[fragile] 618 | \frametitle{continue statement} 619 | \begin{itemize} 620 | \item Jump to end of loop and continue repetition 621 | \end{itemize} 622 | \begin{minted}[bgcolor=Black]{c} 623 | do { 624 | scanf("%f", &a); 625 | scanf("%f", &b); 626 | if(b == 0) 627 | continue; 628 | res = a / b; 629 | printf("a / b = %f\n", res); 630 | } while(a > 0); 631 | \end{minted} 632 | \end{frame} 633 | 634 | \begin{frame} 635 | \frametitle{Which loop?} 636 | \begin{itemize} 637 | \item When you know the number of repetition 638 | \begin{itemize} 639 | \item Counter-controlled loops 640 | \item Usually, \textit{\color{Orange} for} statements 641 | \end{itemize} 642 | \item When you don’t know the number of repetitions (sentinel loop) 643 | \begin{itemize} 644 | \item Some condition should be check before starting loop 645 | \begin{itemize} 646 | \item Usually, \textit{\color{LimeGreen} while} statement 647 | \end{itemize} 648 | \item The loop should be executed at least one time 649 | \begin{itemize} 650 | \item Usually, \textit{\color{Cyan} do-while} 651 | \end{itemize} 652 | \end{itemize} 653 | \end{itemize} 654 | \end{frame} 655 | 656 | \section{Bugs and avoiding them} 657 | 658 | \begin{frame}[fragile] 659 | \frametitle{Common bugs and avoiding them} 660 | \begin{itemize} 661 | \item Loop should terminate 662 | \begin{itemize} 663 | \item 664 | e.g., in for loops, after each iteration, we should approach to the stop 665 | condition 666 | \end{itemize} 667 | \begin{minted}[bgcolor=Black]{c} 668 | for(i = 0; i < 10; i++) // ok 669 | for(i = 0; i < 10; i--) // bug 670 | \end{minted} 671 | \item Initialize loop control variables 672 | \begin{minted}[bgcolor=Black]{c} 673 | int i; 674 | for( ; i < 10; i++) 675 | \end{minted} 676 | \end{itemize} 677 | \end{frame} 678 | 679 | \begin{frame}[fragile] 680 | \frametitle{Common bugs and avoiding them} 681 | \begin{itemize} 682 | \item \textbf{\color{RubineRed} Don’t modify} for loop controller in loop body 683 | \begin{minted}[bgcolor=Black]{c} 684 | for(i = 0; i < 10; i++) { 685 | ... 686 | i--; // bug 687 | } 688 | \end{minted} 689 | \item Take care about wrong control conditions 690 | \begin{itemize} 691 | \item{< vs. <=} 692 | \item{= vs. ==} 693 | \end{itemize} 694 | \begin{minted}[bgcolor=Black]{c} 695 | int b = 10; 696 | int a = 0; 697 | while(a = b) { // it means while(true) 698 | scanf("%d", &a) 699 | } 700 | \end{minted} 701 | \end{itemize} 702 | \end{frame} 703 | 704 | \begin{frame} 705 | \frametitle{Legends} 706 | \begin{figure} 707 | \includegraphics[width=.75\textwidth]{./img/nowruz.jpg} 708 | \end{figure} 709 | \pause% 710 | \centering 711 | \color{Violet} Happy Nowruz 712 | \end{frame} 713 | 714 | \end{document} 715 | -------------------------------------------------------------------------------- /lecture-7/src/do-while-read.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int sum = 0; 5 | int n; 6 | 7 | do { 8 | scanf("%d", &n); 9 | sum += n; 10 | } while(n != 0); 11 | 12 | printf("sum = %d\n", sum); 13 | } 14 | -------------------------------------------------------------------------------- /lecture-7/src/init_with_zero.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int num[100] = {}; 5 | // same as int num[100] = {0}; 6 | 7 | for (int i = 0; i < 100; i++) { 8 | printf("num[%d] = %d\n", i, num[i]); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /lecture-8/img/pass-by-reference-vs-pass-by-value-animation.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-8/img/pass-by-reference-vs-pass-by-value-animation.gif -------------------------------------------------------------------------------- /lecture-8/img/pass-by-value.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-8/img/pass-by-value.png -------------------------------------------------------------------------------- /lecture-8/img/stallman.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-8/img/stallman.jpg -------------------------------------------------------------------------------- /lecture-8/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-8/src/goldbach.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int is_prime(int n) { 4 | if (n < 2) { 5 | return 0; 6 | } 7 | 8 | for (int i = 2; i * i <= n; i++) { 9 | if (n % i == 0) { 10 | return 0; 11 | } 12 | } 13 | return 1; 14 | } 15 | 16 | int next_prime(int n) { 17 | if (n == 2) { 18 | return 3; 19 | } 20 | 21 | n += 2; 22 | while (is_prime(n) == 0) { 23 | n += 2; 24 | } 25 | 26 | return n; 27 | } 28 | 29 | int check_goldbach(int n) { 30 | int i = 2; 31 | 32 | while (i <= n / 2) { 33 | int j = n - i; 34 | if (is_prime(j)) { 35 | printf("%d = %d + %d\n", n, i, j); 36 | 37 | return 1; 38 | } 39 | i = next_prime(i); 40 | } 41 | 42 | return 0; 43 | } 44 | 45 | int main() { 46 | int n; 47 | 48 | do { 49 | scanf("%d", &n); 50 | 51 | if (n > 2 && n % 2 == 0) { 52 | if (check_goldbach(n)) { 53 | printf("golbach is correct\n"); 54 | } else { 55 | printf("golbach is incorrect\n"); 56 | } 57 | } else { 58 | printf("%d is not greater than 2 or it is not even\n", n); 59 | } 60 | } while(n != 0); 61 | } 62 | -------------------------------------------------------------------------------- /lecture-8/src/scope.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int k = 0; 5 | 6 | { 7 | int k = 1; 8 | 9 | printf("inner k = %d\n", k); 10 | 11 | k++; 12 | 13 | printf("inner k = %d\n", k); 14 | } 15 | 16 | printf("outer k = %d\n", k); 17 | } 18 | -------------------------------------------------------------------------------- /lecture-8/src/static.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int lamp_state_change() { 4 | static int is_on = 0; 5 | 6 | printf("is_on = %d\n", is_on); 7 | 8 | if (is_on == 0) { 9 | is_on = 1; 10 | } else { 11 | is_on = 0; 12 | } 13 | 14 | return is_on; 15 | } 16 | 17 | int main() { 18 | // lamp_state_change remembers the last state of the lamp. 19 | lamp_state_change(); 20 | lamp_state_change(); 21 | } 22 | -------------------------------------------------------------------------------- /lecture-9/img/arrays-in-memory.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-9/img/arrays-in-memory.png -------------------------------------------------------------------------------- /lecture-9/img/binary-search.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-9/img/binary-search.png -------------------------------------------------------------------------------- /lecture-9/img/uncle-bob.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1995parham-teaching/c-lecture/08bf1545b2880616207b384b440b11456b9b1cc0/lecture-9/img/uncle-bob.png -------------------------------------------------------------------------------- /lecture-9/latexmkrc: -------------------------------------------------------------------------------- 1 | # based on https://ctan.asis.ai/support/latexmk/example_rcfiles/ 2 | # If equal to 5, generate a pdf version (and an xdv version) of the document using xelatex 3 | $pdf_mode = 5; 4 | $postscript_mode = $dvi_mode = 0; 5 | 6 | # $warnings_as_errors = 1; 7 | 8 | $xelatex = "xelatex --shell-escape %O %S"; 9 | 10 | @default_files = ('main.tex'); 11 | -------------------------------------------------------------------------------- /lecture-9/main.tex: -------------------------------------------------------------------------------- 1 | \documentclass{../c-lecture} 2 | 3 | \subtitle{Arrays} 4 | 5 | \begin{document} 6 | 7 | \begin{frame} 8 | \titlepage{} 9 | \end{frame} 10 | \begin{frame} 11 | \frametitle{Outline} 12 | \tableofcontents{} 13 | \end{frame} 14 | 15 | \section{Introduction} 16 | 17 | \begin{frame} 18 | \frametitle{Introduction} 19 | \begin{itemize} 20 | \item Algorithms usually work on large data sets 21 | \begin{itemize} 22 | \item Sort a set of numbers 23 | \item Search a specific number in a set of numbers 24 | \end{itemize} 25 | \item How to read and store a set of data? 26 | \item To read 27 | \begin{itemize} 28 | \item Repeat the scanf statement 29 | \item Use the loop statements 30 | \end{itemize} 31 | \item To store the data 32 | \begin{itemize} 33 | \item Save each data in a single variable?? 34 | \item 3000 int variables 😱 35 | \end{itemize} 36 | \end{itemize} 37 | \end{frame} 38 | 39 | \begin{frame} 40 | \frametitle{Array} 41 | \begin{itemize} 42 | \item A collection of \textbf{\color{Peach}same type} variables 43 | \item A $n \times 1$ vector of 44 | \begin{itemize} 45 | \item Integers, chars, floats, \ldots 46 | \end{itemize} 47 | \item Example 48 | \begin{itemize} 49 | \item An array of 8 integer 50 | \begin{table} 51 | \begin{tabular}{*{8}{c}} 52 | \toprule 53 | 54 | 0 & 55 | 1 & 56 | 2 & 57 | 3 & 58 | 4 & 59 | 5 & 60 | 6 & 61 | 7 \\ 62 | 63 | \midrule 64 | 65 | 3 & 66 | 1 & 67 | 5 & 68 | 11 & 69 | 10 & 70 | 19 & 71 | 0 & 72 | 12 \\ 73 | 74 | \bottomrule 75 | \end{tabular} 76 | \end{table} 77 | \item An array of 5 chars 78 | \begin{table} 79 | \begin{tabular}{*{5}{c}} 80 | \toprule 81 | 82 | 0 & 83 | 1 & 84 | 2 & 85 | 3 & 86 | 4 \\ 87 | 88 | \midrule 89 | 90 | a & 91 | z & 92 | F & 93 | z & 94 | k \\ 95 | 96 | \bottomrule 97 | \end{tabular} 98 | \end{table} 99 | \end{itemize} 100 | \end{itemize} 101 | \end{frame} 102 | 103 | \begin{frame}[fragile] 104 | \frametitle{Arrays in C} 105 | \begin{itemize} 106 | \item Array declaration in C 107 | \begin{minted}[bgcolor=Black]{c} 108 | [] 109 | \end{minted} 110 | \item 111 | Elements' Type: int, char, float, 112 | \ldots 113 | 114 | \item size: 115 | \begin{itemize} 116 | \item 117 | Old compilers (standard): 118 | \textit{\color{RedOrange} it should be constant} 119 | \item 120 | New compilers (standard): \textit{\color{RubineRed} it can be variable} 121 | \end{itemize} 122 | \item Elements in array 123 | \begin{itemize} 124 | \item From 0 to (size – 1) 125 | \end{itemize} 126 | \end{itemize} 127 | \end{frame} 128 | 129 | \begin{frame}[fragile] 130 | \frametitle{Example} 131 | \mint{c}|int num[20];| 132 | \begin{itemize} 133 | \item 134 | \textit{\color{Orange} num} is array of 20 135 | \textit{\color{LimeGreen} integers} 136 | \item \mintinline{c}|num[0]| is the first integer variable 137 | \item \mintinline{c}|num[19]| is the last integer 138 | \end{itemize} 139 | \mint{c}|float farr[100];| 140 | \begin{itemize} 141 | \item 142 | \textit{\color{YellowOrange} farr} is array of 100 143 | \textit{\color{GreenYellow} floats} 144 | \item \textit{\color{Purple} farr[0]} is the first float 145 | \item 146 | \textit{\color{YellowOrange} farr[49]} is the 50th 147 | \textit{\color{GreenYellow} float} 148 | \item \textit{\color{Purple} farr[99]} is the last float 149 | \end{itemize} 150 | \end{frame} 151 | 152 | \section{Arrays in functions} 153 | 154 | \begin{frame}[fragile] 155 | \frametitle{Arrays in Functions} 156 | \mint{c}|int number[20];| 157 | \begin{itemize} 158 | \item 159 | \textit{\color{LimeGreen} number[i]} is an 160 | \textit{\color{Orange} integer} variable 161 | 162 | \item Array element can be used for call by value input 163 | \item Array element can be use for output 164 | \begin{minted}[bgcolor=Black]{c} 165 | int f(int x); 166 | 167 | void h(void) { 168 | int arr[50]; 169 | // Array element in call by value arr[30] = f(arr[5]); 170 | } 171 | \end{minted} 172 | \end{itemize} 173 | \end{frame} 174 | 175 | \begin{frame}[fragile] 176 | \frametitle{Arrays in Functions (cont’d)} 177 | \begin{itemize} 178 | \item 179 | Array can \textbf{\color{RubineRed} not} be used as output type of 180 | function 181 | \begin{minted}[bgcolor=Black]{c} 182 | int[] f(int x, int y); 183 | // compile error 184 | \end{minted} 185 | \item Arrays can be used in input list of functions 186 | \item 187 | Arrays are \textit{\color{RubineRed} not} passed by Call By Value 188 | \item 189 | Arrays are passed by Call By \textbf{\color{LimeGreen} Reference} 190 | \begin{itemize} 191 | \item If we change array elements in a function 192 | \item The element is changed in the caller function 193 | \end{itemize} 194 | \end{itemize} 195 | \end{frame} 196 | 197 | \begin{frame}[fragile] 198 | \frametitle{Arrays in Functions (version 1)} 199 | \begin{itemize} 200 | \item 201 | Function \textit{\color{Orange} arr\_func} takes an array of 202 | integers 203 | \begin{minted}[bgcolor=Black]{c} 204 | int arr_func(int num[90]) { 205 | } 206 | \end{minted} 207 | \begin{minted}[bgcolor=Black]{c} 208 | int arr_func(int num[]) { 209 | } 210 | \end{minted} 211 | \item 212 | Array \textit{\color{Orange}a} is passed to function 213 | \textit{\color{Orange} arr\_func} 214 | \begin{minted}[bgcolor=Black]{c} 215 | int a[90]; 216 | i = arr_func(a); 217 | \end{minted} 218 | \end{itemize} 219 | \end{frame} 220 | 221 | \begin{frame}[fragile] 222 | \scriptsize 223 | \begin{minted}[bgcolor=Black]{c} 224 | #include 225 | 226 | void init_array(int arr[10]) { 227 | int i; 228 | for(i = 0; i < 10; i++) 229 | arr[i] = i; 230 | } 231 | 232 | void main(void) { 233 | int a[10]; 234 | init_array(a); 235 | int j; 236 | for(j = 0; j < 10; j++) 237 | printf("a[%d] = %d\n", j, a[j]); 238 | } 239 | \end{minted} 240 | \end{frame} 241 | 242 | \begin{frame} 243 | \frametitle{Array Size in Functions} 244 | \begin{block}{} 245 | \begin{itemize} 246 | \item 247 | If array is an \textit{\color{Orange} input parameter} of a 248 | function 249 | \begin{itemize} 250 | \item 251 | It \textit{\color{RubineRed} cannot} find out the size of the array 252 | \end{itemize} 253 | \end{itemize} 254 | \end{block} 255 | \end{frame} 256 | 257 | \begin{frame}[fragile] 258 | \begin{itemize} 259 | \item 260 | Array size should be passed from caller function to called function 261 | \begin{itemize} 262 | \item Using definitions 263 | \begin{minted}[bgcolor=Black]{c} 264 | #define SIZE 20 265 | void func(int a[]) { 266 | for(int i = 0; i < SIZE; i++) 267 | \end{minted} 268 | \item Using input variable 269 | \begin{minted}[bgcolor=Black]{c} 270 | void read(int a[], int size) { 271 | for(int i = 0; i < size; i++) 272 | \end{minted} 273 | \begin{minted}[bgcolor=Black]{c} 274 | void read(int size, int a[size]) { 275 | for(int i = 0; i < size; i++) 276 | \end{minted} 277 | \end{itemize} 278 | \end{itemize} 279 | \end{frame} 280 | 281 | \begin{frame}[fragile] 282 | \frametitle{Array Size in Functions (cont'd)} 283 | \begin{itemize} 284 | \item If array is declared in a function 285 | \begin{itemize} 286 | \item It knows the size of the array 287 | \item 288 | It {\color{Orange} can} find out the size of the array 289 | using {\color{LimeGreen} sizeof} 290 | \end{itemize} 291 | \end{itemize} 292 | \begin{minted}[bgcolor=Black]{c} 293 | void func(void) { 294 | int i, a[200]; 295 | for(i = 0; i < 200; i++) 296 | a[i] = 0; 297 | // or 298 | for(i = 0; i < sizeof(a)/sizeof(a[0]); i++) 299 | a[i] = 0; 300 | } 301 | \end{minted} 302 | \end{frame} 303 | 304 | \begin{frame}[fragile] 305 | \frametitle{Out-of-range access} 306 | \begin{itemize} 307 | \item C compiler does not check the range you access 308 | \begin{itemize} 309 | \begin{minted}[bgcolor=Black]{c} 310 | int x[10]; x[20] = 30; y = x[100]; 311 | \end{minted} 312 | \item No compiler error! 313 | \end{itemize} 314 | \item What happen 315 | \begin{itemize} 316 | \item Read: Logical error 317 | \begin{minted}[bgcolor=Black]{c} 318 | y = x[100]; 319 | \end{minted} 320 | \item Write: May or may not logical or runtime error 321 | \begin{minted}[bgcolor=Black]{c} 322 | x[20] = 30; 323 | \end{minted} 324 | \end{itemize} 325 | \end{itemize} 326 | \end{frame} 327 | 328 | \begin{frame}[fragile] 329 | \frametitle{Out-of-range Example} 330 | \scriptsize 331 | \begin{minted}[bgcolor=Black]{c} 332 | #include 333 | 334 | void init_array(int size, int arr[]) { 335 | int i; 336 | for(i = 0; i < size; i++) 337 | arr[i] = i; 338 | } 339 | 340 | void print_array(int size, int arr[]) { 341 | int i; 342 | for(i = 0; i < size; i++) 343 | printf("arr[%d] = %d\n", i, arr[i]); 344 | } 345 | 346 | void main(void) { 347 | int x = 1, y = 2, a[10] = {0}; 348 | init_array(10, a); // OK 349 | print_array(10, a); // OK 350 | print_array(30, a); // Wrong output 351 | init_array(1000, a); // May be Run-time error! 352 | init_array(20, a); // May changes X, Y! Logical error 353 | printf("x = %d, y = %d\n" , x, y); 354 | } 355 | \end{minted} 356 | \end{frame} 357 | 358 | \begin{frame}[fragile] 359 | \frametitle{Max Index Example} 360 | \scriptsize 361 | \begin{minted}[bgcolor=Black]{c} 362 | #include 363 | 364 | int max_index(int a[], int size){ 365 | int i; 366 | int index = 0; 367 | for(i = 1; i < size; i++) 368 | if(a[i] > a[index]) 369 | index = i; 370 | return index; 371 | } 372 | 373 | void main(void){ 374 | int arr[] = {1, 4, 12, 93, 23}; 375 | printf("max index = %d\n", max_index(arr, 5)); 376 | } 377 | \end{minted} 378 | \end{frame} 379 | 380 | \begin{frame}[fragile] 381 | \frametitle{Array Swap Example} 382 | \scriptsize 383 | \begin{minted}[bgcolor=Black]{c} 384 | #include 385 | 386 | void array_swap(int a[], int i, int j){ 387 | int tmp; 388 | tmp = a[i]; 389 | a[i] = a[j]; 390 | a[j] = tmp; 391 | } 392 | 393 | void main(void){ 394 | int num[10] = {1, 2, 5, 6}; 395 | int x = 2, y = 6; 396 | 397 | printf("num[%d] = %d, num[%d] = %d\n", x, num[x], y, num[y]); 398 | array_swap(num, x, y); 399 | printf("num[%d] = %d, num[%d] = %d\n", x, num[x], y, num[y]); 400 | } 401 | \end{minted} 402 | \end{frame} 403 | 404 | \begin{frame}[fragile] 405 | \frametitle{Sort} 406 | \scriptsize 407 | \begin{minted}[bgcolor=Black]{c} 408 | #include 409 | 410 | void array_swap(int a[], int i, int j){ 411 | int tmp; 412 | tmp = a[i]; 413 | a[i] = a[j]; 414 | a[j] = tmp; 415 | } 416 | 417 | void selection_sort(int a[], int size){ 418 | int i, j; 419 | 420 | for(i = 0; i < size - 1; i++) 421 | for(j = i + 1; j < size; j++) 422 | if(a[i] > a[j]) 423 | array_swap(a, i, j); 424 | } 425 | \end{minted} 426 | \end{frame} 427 | 428 | \begin{frame}[fragile] 429 | \frametitle{Sort (Cont'd)} 430 | \scriptsize 431 | \begin{minted}[bgcolor=Black]{c} 432 | #include 433 | 434 | void print(int a[], int size) { 435 | int i; 436 | for(i = 0; i < size; i++) 437 | printf("%d ", a[i]); 438 | printf("\n"); 439 | } 440 | 441 | int main(void) { 442 | int arr[] = {1, 7, 3, 7, 11, 0}; 443 | int size = sizeof(arr) / sizeof(arr[0]); 444 | 445 | printf("Before sort: "); 446 | print(arr, size); 447 | 448 | selection_sort(arr, size); 449 | 450 | printf("After sort: "); 451 | print(arr, size); 452 | 453 | return 0; 454 | } 455 | \end{minted} 456 | \end{frame} 457 | 458 | \begin{frame} 459 | \frametitle{Binary Search} 460 | \begin{itemize} 461 | \item 462 | Given a \textbf{\color{YellowOrange} sorted array} arr[] of n elements, 463 | write a function to 464 | \textbf{\color{GreenYellow} search a given element} x in arr[]. 465 | \end{itemize} 466 | \begin{figure} 467 | \includegraphics[width=.75\textwidth]{./img/binary-search.png} 468 | \end{figure} 469 | \end{frame} 470 | 471 | \begin{frame}[fragile] 472 | \scriptsize 473 | \begin{minted}[bgcolor=Black]{c} 474 | int bsearch(int start, int end, int a[], int value){ 475 | int mid = (start + end) / 2; 476 | 477 | if(a[mid] == value) 478 | return mid; 479 | else if(start >= end) 480 | return -1; 481 | else if(value > a[mid]) 482 | return bsearch(mid + 1, end, a, value); 483 | else 484 | return bsearch(start, mid - 1 , a, value); 485 | } 486 | \end{minted} 487 | \end{frame} 488 | 489 | \section{Multidimensional arrays} 490 | 491 | \begin{frame}[fragile] 492 | \frametitle{Multidimensional Arrays} 493 | \begin{itemize} 494 | \item 495 | If element of an array is array itself, it will be Multidimensional array 496 | 497 | \begin{minted}[bgcolor=Black]{c} 498 | int t[10][20]; 499 | \end{minted} 500 | \item $10 \times 20$ matrix of integers 501 | \begin{minted}[bgcolor=Black]{c} 502 | t[1][1]; 503 | // t[1,1] // compile error 504 | \end{minted} 505 | \item Integer variable in location (1,1) 506 | \end{itemize} 507 | \end{frame} 508 | 509 | \begin{frame}[fragile] 510 | \frametitle{Initializing Multidimensional Arrays} 511 | \begin{itemize} 512 | \begin{minted}[bgcolor=Black]{c} 513 | int num[2][3] = {1, 2, 0, 3, 4, 7}; 514 | int num[2][3] = { {1, 2, 0}, {3, 4, 7} }; 515 | \end{minted} 516 | \item num[0][2] is 0, num[1][0] is 3 517 | \begin{minted}[bgcolor=Black]{c} 518 | int num[5][3] = { {1, 2, 0}, {3, 4, 7} }; 519 | \end{minted} 520 | \item num[2][2] is 0, num[1][2] is 7 521 | \end{itemize} 522 | \end{frame} 523 | 524 | \begin{frame}[fragile] 525 | \begin{itemize} 526 | \begin{minted}[bgcolor=Black]{c} 527 | int num[2][3][2] = { { {1, 2}, {3, 4}, {5, 6} }, { {1}, {2}, {3} } }; 528 | \end{minted} 529 | \item num[0][2][1] is 6, num[1][0][1] is 0 530 | \begin{minted}[bgcolor=Black]{c} 531 | int num[][2] = { {1, 1}, {2, 2}, {3, 3} }; 532 | \end{minted} 533 | \item num[1][1] is 2, num[2][0] is 3 534 | \item 535 | All dimentions 536 | \textbf{\color{Orange} except the first one} \textbf{\color{Yellow} are required} in 537 | initiation 538 | \end{itemize} 539 | \end{frame} 540 | 541 | \begin{frame}[fragile] 542 | \frametitle{Multidimensional Arrays in Functions} 543 | \begin{itemize} 544 | \item 545 | Can be used as input of functions. All dimensions except the first one 546 | {\color{YellowOrange} must} be given. 547 | 548 | \begin{minted}[bgcolor=Black]{c} 549 | void func(int a[10][20][5]); 550 | \end{minted} 551 | \begin{itemize} 552 | \item Input is a $10 \times 20 \times 5$ integer matrix 553 | \end{itemize} 554 | \begin{minted}[bgcolor=Black]{c} 555 | void func(int a[][20][30], int size); 556 | \end{minted} 557 | \begin{minted}[bgcolor=Black]{c} 558 | void func(int size1, int size2, int a[size1][size2]); 559 | \end{minted} 560 | \begin{itemize} 561 | \item 562 | Input is a matrix of integers that both rows and columns are variable 563 | \end{itemize} 564 | \end{itemize} 565 | \end{frame} 566 | 567 | \begin{frame}[fragile] 568 | \frametitle{Matrix Transpose} 569 | \scriptsize 570 | \begin{minted}[bgcolor=Black]{c} 571 | #define SIZE 5 572 | 573 | void swap(int a[SIZE][SIZE], int i, int j) { 574 | int tmp; 575 | tmp = a[i][j]; 576 | a[i][j] = a[j][i]; 577 | a[j][i] = tmp; 578 | } 579 | 580 | void transpose(int a[][SIZE]) { 581 | int i, j; 582 | for(i = 0; i < SIZE; i++) 583 | for(j = i; j < SIZE; j++) 584 | swap(a, i, j); 585 | } 586 | \end{minted} 587 | \end{frame} 588 | 589 | \begin{frame}[fragile] 590 | \frametitle{Matrix Print} 591 | \scriptsize 592 | \begin{minted}[bgcolor=Black]{c} 593 | #include 594 | 595 | void display_matrix(int n_rows, int n_cols, int matrix[n_rows][n_cols]) { 596 | int row, column; 597 | 598 | for (row = 0; row < n_rows; row++) { 599 | for (column = 0; column < n_cols; column++) 600 | printf("%5d ", matrix[row][column]); 601 | printf("\n"); 602 | } 603 | } 604 | 605 | int main (void){ 606 | int sample[3][5] = 607 | { 608 | { 7, 16, 55, 13, 12 }, 609 | { 12, 10, 52, 0, 7 }, 610 | { -2, 1, 2, 4, 9 } 611 | }; 612 | printf("Original matrix:\n"); 613 | display_matrix(3, 5, sample); 614 | } 615 | \end{minted} 616 | \end{frame} 617 | 618 | \begin{frame}[fragile] 619 | \begin{minted}[bgcolor=Black]{output} 620 | Original matrix: 621 | 7 16 55 13 12 622 | 12 10 52 0 7 623 | -2 1 2 4 9 624 | \end{minted} 625 | \end{frame} 626 | 627 | \begin{frame} 628 | \frametitle{Array In Memory} 629 | \begin{figure} 630 | \includegraphics[width=.75\textwidth]{./img/arrays-in-memory.png} 631 | \end{figure} 632 | \end{frame} 633 | 634 | \begin{frame}[fragile] 635 | \begin{minted}[bgcolor=Black]{c} 636 | #include 637 | 638 | int main() { 639 | int arr[][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; 640 | 641 | printf("%lu\n", sizeof(arr)); // 36 = 9 * 4 = 9 * sizeof(int) 642 | } 643 | \end{minted} 644 | \begin{block}{} 645 | There is no way to findout dimensions of an array 646 | \end{block} 647 | \end{frame} 648 | 649 | \section{String} 650 | 651 | \begin{frame}[fragile] 652 | \frametitle{Introduction} 653 | \begin{itemize} 654 | \item Until now 655 | \begin{itemize} 656 | \item We have seen strings in \textit{\color{Cyan} printf} 657 | \item Our old definition: string is a set of char between `` '' 😂 658 | \begin{minted}[bgcolor=Black]{c} 659 | printf("This is a string\n"); 660 | printf("This is %s\n", "a string\n"); 661 | \end{minted} 662 | \end{itemize} 663 | \item Strings: 664 | \begin{itemize} 665 | \item An array of chars 666 | \item Terminated by the \textit{\color{Orange} null char} \mintinline{c}|'\0'| 667 | \end{itemize} 668 | \end{itemize} 669 | \end{frame} 670 | 671 | \begin{frame}[fragile] 672 | \frametitle{Strings in C} 673 | \begin{itemize} 674 | \item Since strings are array 675 | \end{itemize} 676 | \begin{minted}[bgcolor=Black]{c} 677 | char str1[] = {'p', 'r', 'o', 'g', 'r', 'a', 'm', '\0'}; 678 | char str2[8] = "program"; 679 | char str3[] = "program"; 680 | char *str4 = "program"; //we will see later 681 | \end{minted} 682 | \begin{table} 683 | \begin{tabular}{*{8}{c}} 684 | \toprule 685 | 'p' & 686 | 'r' & 687 | 'o' & 688 | 'g' & 689 | 'r' & 690 | 'a' & 691 | 'm' & 692 | {\color{Orange} '\textbackslash 0'} \\ 693 | \bottomrule 694 | \end{tabular} 695 | \end{table} 696 | \end{frame} 697 | 698 | \begin{frame}[fragile] 699 | \frametitle{Reading \& Writing Strings} 700 | \begin{itemize} 701 | \item \textit{\color{SpringGreen} printf} can be used to print strings 702 | \begin{minted}[bgcolor=Black]{c} 703 | printf("program"); 704 | printf("%s", "program"); 705 | \end{minted} 706 | \end{itemize} 707 | \begin{itemize} 708 | \item \textit{\color{LimeGreen} scanf} can be used to read strings 709 | \begin{minted}[bgcolor=Black]{c} 710 | char str[200]; 711 | scanf("%s", str); 712 | \end{minted} 713 | \item Initial white spaces are ignored 714 | \item 715 | Read until \textit{\color{Orange} space} or 716 | \mintinline{c}|'\n'| (which is replaced by \mintinline{c}|\0|) 717 | 718 | \item We must allocate \textbf{\color{RubineRed} sufficient size} 719 | \end{itemize} 720 | \end{frame} 721 | 722 | \begin{frame} 723 | \frametitle{Reading \& Writing Strings (cont’d)} 724 | \begin{itemize} 725 | \item 726 | \textit{\color{YellowOrange} puts(str)} is \textsc{\color{Cyan} very} simple version of 727 | \textit{\color{LimeGreen}printf} 728 | 729 | \begin{itemize} 730 | \item Can only be used to print strings 731 | \item Adds \mintinline{c}|'\n'| to end of string 732 | \end{itemize} 733 | \item 734 | \textit{\color{YellowOrange} gets(char str[])} can be used to read 735 | strings 736 | 737 | \item 738 | \textit{\color{YellowOrange} gets} does 739 | \textsc{\color{RubineRed} not} ignore the white spaces 740 | 741 | \begin{itemize} 742 | \item Read until \mintinline{c}|'\n'| 743 | \end{itemize} 744 | \item String should be large enough 745 | \end{itemize} 746 | \end{frame} 747 | 748 | \section{String functions} 749 | 750 | \begin{frame}[fragile] 751 | \frametitle{String Library} 752 | \begin{itemize} 753 | \item Access to string library by 754 | \begin{minted}[bgcolor=Black]{c} 755 | #include 756 | \end{minted} 757 | \item Many functions to work with strings 758 | \begin{itemize} 759 | \item Find the length of string 760 | \item Compare strings 761 | \item Copy strings 762 | \item Search in strings 763 | \item \ldots 764 | \end{itemize} 765 | \end{itemize} 766 | \end{frame} 767 | 768 | \begin{frame}[fragile] 769 | \frametitle{Length of String} 770 | \begin{itemize} 771 | \item \textit{\color{YellowOrange} strlen(str)}: Length of string 772 | \item 773 | From start to first occurrence of the 774 | \textsc{\color{LimeGreen} null} char 775 | 776 | \end{itemize} 777 | \begin{minted}[bgcolor=Black]{c} 778 | char str[] = "This is test"; 779 | char str1[10] = {'a', 'b', '\0', 'c', '\0'}; 780 | strlen(str) // returns 12 781 | strlen(str1) // returns 2 😱 782 | \end{minted} 783 | \end{frame} 784 | 785 | \begin{frame} 786 | \frametitle{Compare Strings} 787 | \begin{itemize} 788 | \item str1 and str2 are compared as follows 789 | \begin{itemize} 790 | \item 791 | Compare \textit{\color{LimeGreen} char by char} from 792 | \textit{\color{Cyan} left to right} until str1 and str2 has same 793 | chars. 794 | 795 | \item In the first different char 796 | \begin{itemize} 797 | \item if (char of str1 < char of str2) \textrightarrow str1 < str2 798 | \end{itemize} 799 | \item if (both string finish) \textrightarrow str1 = str2 800 | \end{itemize} 801 | \item 802 | \textit{\color{YellowOrange} strcmp(str1, str2)}:compare str1 and str2 803 | \end{itemize} 804 | \end{frame} 805 | 806 | \begin{frame}[fragile] 807 | \frametitle{Compare Strings: Examples} 808 | \begin{minted}[bgcolor=Black]{c} 809 | char s1[] = "abc"; 810 | char s2[] = "abc"; 811 | i = strcmp(s1, s2); // i = 0, s1 is equal to s2 812 | 813 | char s3[] = "abc"; 814 | char s4[] = "abx"; 815 | i = strcmp(s3, s4); // i = -1, s3 is lower than s4 816 | 817 | char s5[] = "axc"; 818 | char s6[] = "abc"; 819 | i = strcmp(s5, s6); // i = 1, s5 is greater than s6 820 | 821 | char s7[] = "ab"; 822 | char s8[] = "abc"; 823 | i = strcmp(s7, s8); // i = -1, s7 is lower than s8 824 | 825 | char s9[] = "abc"; 826 | char s10[] = "aBc"; 827 | i = strcmp(s9, s10); // i = 1, s9 is greater than s10 828 | \end{minted} 829 | \end{frame} 830 | 831 | \begin{frame}[fragile] 832 | \frametitle{Compare Strings} 833 | \begin{itemize} 834 | \item \textit{\color{YellowOrange} strcmpi(str1, str2)} 835 | \item Compares str1 and str2 similar to strcmp 836 | \item But ignores uppercase/lowercase difference 837 | \end{itemize} 838 | \begin{minted}[bgcolor=Black]{c} 839 | char str1[] = "ABC"; 840 | char str2[] = "abC"; 841 | strcmpi(str1, str2) // 0 842 | \end{minted} 843 | \end{frame} 844 | 845 | \begin{frame} 846 | \frametitle{Copy Strings} 847 | \begin{itemize} 848 | \item Strings should be copied char by char 849 | \item 850 | \mintinline{c}|strcpy(dst_str, src_str)|: copy the 851 | \mintinline{c}|src_str| to the 852 | \mintinline{c}|dst_str| including NULL 853 | 854 | \item 855 | \mintinline{c}|src_str| is a 856 | \textbf{\color{YellowOrange} constant} string 857 | 858 | \item 859 | \mintinline{c}|dst_str| should have 860 | \textbf{\color{YellowOrange} sufficient size} 861 | \end{itemize} 862 | \end{frame} 863 | 864 | \begin{frame}[fragile] 865 | \frametitle{Copy Strings: Example} 866 | \begin{minted}[bgcolor=Black]{c} 867 | char str1[] = "Test String"; 868 | char str2[20]; 869 | 870 | strcpy(str2, str1); 871 | 872 | printf("%s\n", str2); // Test String 873 | printf("%s\n", str1); // Test String 874 | \end{minted} 875 | \end{frame} 876 | 877 | \begin{frame} 878 | \frametitle{Concatenate Strings} 879 | \begin{itemize} 880 | \item 881 | \mintinline{c}|strcat(dst_str, src_str)|: Append the 882 | \mintinline{c}|src| string to the end of 883 | \mintinline{c}|dst| including NULL 884 | \item 885 | \mintinline{c}|src| is a 886 | \textbf{\color{YellowOrange} constant} string 887 | \item 888 | \mintinline{c}|dst| should have 889 | \textbf{\color{YellowOrange} sufficient space} 890 | \end{itemize} 891 | \end{frame} 892 | 893 | \begin{frame}[fragile] 894 | \frametitle{Concatenate Strings: Example} 895 | \begin{minted}[bgcolor=Black]{c} 896 | char str1[] = "String"; 897 | char str2[20] = "Test "; 898 | 899 | strcat(str2, str1); 900 | 901 | printf("%s\n", str2); // Test String 902 | \end{minted} 903 | \end{frame} 904 | 905 | \begin{frame} 906 | \frametitle{Sized Version of the Functions} 907 | \begin{itemize} 908 | \item \textit{\color{YellowOrange} strncpy(dst, src, n):} 909 | \begin{itemize} 910 | \item 911 | copys \textit{\color{RubineRed} n} chars from 912 | \textit{\color{Cyan} src} to \textit{\color{Melon} dst} 913 | 914 | \item if(strlen(src) > n) 915 | \begin{itemize} 916 | \item Copies n chars to \textit{\color{Melon} dst} 917 | \item 918 | Does not add \mintinline{c}|'\0'| to end of \textit{\color{Melon} dst} 919 | 920 | \end{itemize} 921 | \item if(strlen(src) < n) 922 | \begin{itemize} 923 | \item 924 | Copy \textit{\color{Cyan} src} to 925 | \textit{\color{Melon} dst} 926 | 927 | \item 928 | Add n – strlen(src) – 1 \mintinline{c}|'\0'|s to end of 929 | dst 930 | 931 | \item \textit{\color{Melon} dst} must be large enough 932 | \item n < size of dst 933 | \end{itemize} 934 | \end{itemize} 935 | \end{itemize} 936 | \end{frame} 937 | 938 | \begin{frame} 939 | \frametitle{Sized Version of the Functions} 940 | \begin{itemize} 941 | \item \textit{\color{YellowOrange}strncmp(str1, str2, n)}: 942 | \begin{itemize} 943 | \item compares the first \textit{\color{LimeGreen}x} chars 944 | \item 945 | \textit{\color{LimeGreen} x} = min( n, strlen(str1) + 1, 946 | strlen(str2) + 1 ) 947 | 948 | \end{itemize} 949 | \item \mintinline{c}|strncat(dst, src, n)|: 950 | \begin{itemize} 951 | \item 952 | Appends the \textit{\color{LimeGreen} x} chars from src to dst 953 | 954 | \item \textit{\color{LimeGreen} x} = min( n, strlen(src) ) 955 | \item 956 | Adds \mintinline{c}|'\0'| to end of dst \textbf{\color{RubineRed} unlike} 957 | \textit{\color{Cyan} strncpy} 958 | 959 | \item dst must be large enough 960 | \end{itemize} 961 | \end{itemize} 962 | \end{frame} 963 | 964 | \begin{frame}[fragile] 965 | \begin{minted}[bgcolor=Black]{c} 966 | char s1[] = "Hello"; 967 | char s2[] = "Hell"; 968 | 969 | printf("%d\n", strcmp(s1, s2)); // s1 > s2 970 | printf("%d\n", strncmp(s1, s2, 2)); // s1 == s2 971 | printf("%d\n", strncmp(s1, s2, 4)); // s1 == s2 972 | printf("%d\n", strncmp(s1, s2, 5)); // s1 > s2 973 | \end{minted} 974 | \end{frame} 975 | 976 | \begin{frame}[fragile] 977 | \frametitle{Numbers and Strings: number \textrightarrow string} 978 | \begin{itemize} 979 | \item To convert a number to string 980 | \begin{minted}[bgcolor=Black]{c} 981 | #include // sprintf 982 | 983 | char str1[100]; 984 | 985 | int i = 100; 986 | sprintf(str1, "%d", i); // str1 = “100” 987 | 988 | float f = 10.11; 989 | sprintf(str1, "%0.2f", f); // str1 = “10.11” 990 | 991 | \end{minted} 992 | \item 993 | String \textit{\color{YellowOrange} str1} should have 994 | \textit{\color{CarnationPink} sufficient size} 995 | 996 | \end{itemize} 997 | \end{frame} 998 | 999 | \begin{frame}[fragile] 1000 | \frametitle{Numbers and Strings: string \textrightarrow number} 1001 | \begin{itemize} 1002 | \item To convert from strings to numbers 1003 | \begin{minted}[bgcolor=Black]{c} 1004 | #include // atoi, atof 1005 | #include // sscanf 1006 | 1007 | char str1[] = "10"; 1008 | int i; 1009 | i = atoi(str1); // i = 10 1010 | sscanf(str1, "%d", &i); // i = 10 1011 | 1012 | char str2[] = "20.44"; 1013 | double f; 1014 | f = atof(str2); // f = 20.44 1015 | sscanf(str2, "%lf", &f); // f = 20.44 1016 | \end{minted} 1017 | \end{itemize} 1018 | \end{frame} 1019 | 1020 | \begin{frame}[fragile] 1021 | \frametitle{String as Array} 1022 | \begin{itemize} 1023 | \item Strings are array of chars 1024 | \item We work on arrays element by element 1025 | \item We can work on strings char by char 1026 | \begin{minted}[bgcolor=Black]{c} 1027 | char str1[] = "100000"; 1028 | str1[2] = '2'; 1029 | \end{minted} 1030 | \item We can pass strings to functions 1031 | \end{itemize} 1032 | \end{frame} 1033 | 1034 | \begin{frame}[fragile] 1035 | \frametitle{Array of Strings} 1036 | \begin{itemize} 1037 | \item 2 dimensional array, each row is a string 1038 | \scriptsize 1039 | \begin{minted}[bgcolor=Black]{c} 1040 | char numeri[][8] = { "zero", "uno", "due", "tre", "quattro" }; 🇮🇹 1041 | char numeri[][] = { "zero", "uno", "due", "tre", "quattro" }; // Compile Error 1042 | \end{minted} 1043 | \begin{table} 1044 | \begin{tabular}{*{8}{c}} 1045 | \toprule 1046 | 'z' & 1047 | 'e' & 1048 | 'r' & 1049 | 'o' & 1050 | '\textbackslash 0' & 1051 | '\textbackslash 0' & 1052 | '\textbackslash 0' & 1053 | '\textbackslash 0' \\ 1054 | \midrule 1055 | 'u' & 1056 | 'n' & 1057 | 'o' & 1058 | '\textbackslash 0' & 1059 | '\textbackslash 0' & 1060 | '\textbackslash 0' & 1061 | '\textbackslash 0' & 1062 | '\textbackslash 0' \\ 1063 | \midrule 1064 | 'd' & 1065 | 'u' & 1066 | 'e' & 1067 | '\textbackslash 0' & 1068 | '\textbackslash 0' & 1069 | '\textbackslash 0' & 1070 | '\textbackslash 0' & 1071 | '\textbackslash 0' \\ 1072 | \midrule 1073 | 't' & 1074 | 'r' & 1075 | 'e' & 1076 | '\textbackslash 0' & 1077 | '\textbackslash 0' & 1078 | '\textbackslash 0' & 1079 | '\textbackslash 0' & 1080 | '\textbackslash 0' \\ 1081 | \midrule 1082 | 'q' & 1083 | 'u' & 1084 | 'a' & 1085 | 't' & 1086 | 't' & 1087 | 'r' & 1088 | 'o' & 1089 | '\textbackslash 0' \\ 1090 | \bottomrule 1091 | \end{tabular} 1092 | \end{table} 1093 | \end{itemize} 1094 | \end{frame} 1095 | 1096 | \begin{frame} 1097 | \frametitle{ctype.h} 1098 | \begin{itemize} 1099 | \item Many function to work on chars 1100 | \begin{itemize} 1101 | \item Check digit 1102 | \item Check alphabetic 1103 | \item Check lower or upper case 1104 | \item Convert from/to upper/lower case 1105 | \end{itemize} 1106 | \end{itemize} 1107 | \end{frame} 1108 | 1109 | \begin{frame} 1110 | \frametitle{ctype.h} 1111 | \begin{itemize} 1112 | \item int isdigit(ch) 1113 | \begin{itemize} 1114 | \item Check ch is digital char or not 1115 | \end{itemize} 1116 | 1117 | \pause 1118 | 1119 | \item int isalpha(ch) 1120 | \begin{itemize} 1121 | \item Check ch is alphabetic or not 1122 | \end{itemize} 1123 | 1124 | \pause 1125 | 1126 | \item int islower(ch) 1127 | \begin{itemize} 1128 | \item Check ch is lowercase alphabetic or not 1129 | \end{itemize} 1130 | 1131 | \pause 1132 | 1133 | \item int isupper(ch) 1134 | \begin{itemize} 1135 | \item Check ch is uppercase alphabetic or not 1136 | \end{itemize} 1137 | 1138 | \pause 1139 | 1140 | \item char tolower(ch) 1141 | \begin{itemize} 1142 | \item Convert ch to lowercase and return it 1143 | \end{itemize} 1144 | 1145 | \pause 1146 | 1147 | \item char toupper(ch) 1148 | \begin{itemize} 1149 | \item Convert ch to upper case and return it 1150 | \end{itemize} 1151 | \end{itemize} 1152 | \end{frame} 1153 | 1154 | \section{Bugs and avoiding them} 1155 | 1156 | \begin{frame} 1157 | \frametitle{Common Bugs \& Avoiding them} 1158 | \begin{itemize} 1159 | \item Strings which are used as destination 1160 | \begin{itemize} 1161 | \item scanf, sprintf, strcpy, \ldots 1162 | \item Must be large enough 1163 | \end{itemize} 1164 | \item Take care about the \mintinline{c}|'\0'| 1165 | \begin{itemize} 1166 | \item You should never destroy it, some library functions do! 1167 | \end{itemize} 1168 | \item 1169 | Out of range array index!!!! (read/write, wrong size in function, 1170 | multidimensional array memory) 1171 | \end{itemize} 1172 | \end{frame} 1173 | 1174 | \begin{frame}[fragile] 1175 | \frametitle{Common Bugs \& Avoiding them} 1176 | \begin{itemize} 1177 | \item You cannot assign a value to array 1178 | \scriptsize 1179 | \begin{minted}[bgcolor=Black]{c} 1180 | int a[4], b[4]; 1181 | a = b; // error: assignment to expression with array type 1182 | a = 4; // error: assignment to expression with array type 1183 | \end{minted} 1184 | \normalsize 1185 | \item To debug 1186 | \begin{itemize} 1187 | \item Print the array index and corresponding value 1188 | \end{itemize} 1189 | \end{itemize} 1190 | \end{frame} 1191 | 1192 | \end{document} 1193 | -------------------------------------------------------------------------------- /lecture-9/src/bsearch.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int bsearch(int start, int end, int arr[], int value) { 4 | int mid = (start + end) / 2; 5 | 6 | printf("start: %d, end: %d, mid: %d\n", start, end, mid); 7 | 8 | if (arr[mid] == value) { 9 | return mid; 10 | } else if (start == end) { 11 | return -1; 12 | } else if (arr[mid] > value) { 13 | return bsearch(start, mid - 1, arr, value); 14 | } else { 15 | return bsearch(mid + 1, end, arr, value); 16 | } 17 | } 18 | 19 | int main() { 20 | int arr[] = {1, 10, 30, 45, 90, 186, 1024}; 21 | int size = sizeof(arr) / sizeof(arr[0]); 22 | 23 | int index = bsearch(0, size - 1, arr, 95); 24 | printf("index = %d\n", index); 25 | } 26 | --------------------------------------------------------------------------------