C++ Tutorials - Absolute n00b spoonfeed

By request I will try to post an index to all tutorial videos right here. This list will hopefuly be updated regularly.

Tutorial (1)
* Introduction
* Program / Programming
* Programming languages
* C++ Programming language


Tutorial (2)
* Interpreted vs. Compiled
* C++ Compiler


Tutorial (3)
* Different compilers / same stuff
* Project
* Console / Window / etc
* Hello world code
* Build/Compile/Run/Debug
* Typing mistakes


Tutorial (4)
(Updated version 1)
* Fundamental Commands/Instructions/Keywords
* Custom made Commands/Instructions...
* .cpp .c / .hpp .h files (source/header)
* Including headers in source files
* Using stuff from header files
* Functions
* The c++ main function


Tutorial (5)
(Updated version 1)
* printing text
* semicolon
* whitespace and clarity
* wait for some typing
* cAsE-senSitIvitY
* return where you came from


Tutorial (6)
(updated version 1)
* Text vs Code
* Escape characters
* Math Calculations


Tutorial (7)
(updated version 1)
* Variables
* Integer type


Tutorial (8)
* int, short, long
* unsigned short
* unsigned long
* signed short
* signed long
* cout concatenation


Tutorial (9)
* float, double, integer truncation
* char


Tutorial (10)
* rvalue / lvalue
* expressions


Tutorial (11)
* Operators = + - / * %
* Integer/Float/Char Casting/Truncation


Tutorial (12)
* const
* bool
* Operators += -= *= /= %=


Tutorial (13)
* Operators ++ -- (prefix/postfix)
* if/else statements intro


Tutorial (14)
* if/else statements
* Operators equals/more-than/less-than

Tutorial (15)
* operators not-equals/more-or-equals/less-or-equals
* nested if/else statements


Tutorial (16)
* More on if/else statements
* Braces
* When the if/else statement is over


Tutorial (17)
* Logical Operators
* Operator Precedence problem
* Parenthesis and clarity


Tutorial wrap 1 (@ 17)

Tutorial wrap 2 (@ 17)

Tutorial wrap 3 (@ 17)

Tutorial wrap 4 (@ 17)

Tutorial (18)
* Function definitions
* Declaration order
* Calling/returning


Tutorial (19)
* Functions' returning values / return type


Tutorial (20)
(updated version 1)
* void and returning
* Returning immediately
* More than one return statement
* Variable scope/visibility


Tutorial (21)
(updated version 1)
* More variable scope/visibility


Tutorial (22)
* for loop


Tutorial (23)
* more on for loop
* break
* while loop
* do while loop


Tutorial (24)
* More on loops
* continue


Tutorial (25)
* Scope/Visibility in loops
* Conditional operator


Tutorial (26)
* switch statement


Tutorial (27)
* Declaration / Definition
* Passing variables to functions


Tutorial (28)
* Passing by value
* returning one result


Tutorial (29)
* Intro to OOP
* Partial syntax overview


Tutorial (30)
* classes are like variables
* member variables / methods
* creating an instance
* dot operator


Tutorial (31)
* OOP Design
* public / private
* public functions / private data


Tutorial (32)
* OOP Encapsulation
* Types of variables / Instances of variables


Tutorial (33)
* methods work exactly as functions
* ISO Standard C++
* Standard Library headers


Tutorial (34)
* creating arrays
* offset zero
* array boundaries


Tutorial (35)
* More on arrays
* standard string


Tutorial (36)
* member variable scope in methods
* passing a int rvalue (literal constant) into a function
* problem of using uninitialized member variables


Tutorial (37)
* (default) constructor
* making your own constructor
* passing to constructors
* initializer list


Tutorial (38)
* OOP Encapsulation
* class declaration / definition
* methods & functions- same rules (pretty much)


Tutorial (39)
class declarations in headers, definitions in source files.


Tutorial (40)
* source files are separate entities
* header files for declaration
* linker to the rescue


Tutorial wrap 1 (@ 40)
* some corrections
* comments


Tutorial wrap 2 (@ 40)
* more on comments
* more on passing into functions
* more on returning from functions


Tutorial wrap 3 (@ 40)
* casting basic types
* name clashes


Tutorial wrap 4 (@ 40)
* standard c++


Tutorial wrap 5 (@ 40)
* passing custom types
* returning custom types
* class scope


Tutorial wrap 6 (@ 40)
* warning - stay tuned


Tutorial wrap 7 (@ 40)
* cross-referencing c++ concepts


Tutorial (41)
* problem of scope limitations


Tutorial (42)
* variables in RAM
* memory addresses


Tutorial (43)
* address operator
* pointers


Tutorial (44)
* using pointers
* overcoming scope


Tutorial (45)
* more about pointers
* arrays are pointers


Tutorial (46)
* dangers of pointers


Tutorial (47)
* more dangers of pointers


Tutorial (48)
* heap memory allocation


Tutorial (49)
* 'delete'ing heap memory
* bypassing scope by passing memory address


Tutorial (50)
* more about 'delete'ing
* vital advice about heap memory


Tutorial (51)
* more heap-memory ugliness
* OOP insight


Tutorial (52)
* const/non-const pointers to const/non-const variables


Tutorial (53)
* const/non-const pointers to const/non-const variables
* write protection with const


Tutorial (54)
* passing by value vs passing by reference


Tutorial (55)
* returning by reference
* passing objects of classes by value
* the copy constructor


Tutorial (56)
* references


Tutorial (57)
* references continued


Tutorial (58)
* more references continued


Tutorial (59)
* function overloading


Tutorial (60)
* constructor overloading
* default parameters


Tutorial (wrap 1 at 60)
* function overloading + default parameters = ambiguity
* dont be using namespace std;


Tutorial (wrap 2 at 60)
* rule 1: declaration
* rule 2: OOP
(continued in next vid...)


Tutorial (wrap 3 at 60)
* (continued) the compiler and translation units
(continued in next vid...)


Tutorial (wrap 4 at 60)
* (continued) inclusion / linker / compiler / declaration and definition


Tutorial (61)
* inclusion guards

You should really try to add descriptions to videos 25+. Seeing that looking at every single video to find which one you want is cumbersome, having this little archive of sorts really takes the "meaningless meandering" out of trying to find what we want. :]

im sure he is busy and will eventually get to it. just be patient, or make one your self.

anitRTFM is busy right now.
And everyone is lucky he made the videos in the first place.

If that wasn't enough, the guy decided to make an entire forum just to benifit all these people that are trying to learn C++.

Then...... If that's not enough. He's on here like twice a day to help everyone with there problems.

Just be greatful for the things you have.

I think i gave the wrong impression I am very grateful for the videos he made, and all the time he put into this all! When I said "You should try to....." i meant "please add it in if you have any free time!". Though now that you mention it, i think i might just post the descriptions here, and then all he has to do is copy paste it into his post, seeing that he probably is very busy most of the time.....


EDIT: The "doublepost" below is intentional, because it makes it more organized for antiRTFM to go and copy paste it in the future if he wants..

Heres the descriptions that i got.... Hope this makes it up for being a 'lil rude before: That was uncalled for, seeing how much you help us.


Part 25:
* Scope/Visibility in loops
* Conditional operator

Part 26:
* switch statement

Part 27:
* Declaration / Definition
* Passing variables to functions

Part 28:
* Passing by value
* returning one result

Part 29:
* Intro to OOP
* Partial syntax overview

Part 30:
* classes are like variables
* member variables / methods
* creating an instance
* dot operator

Part 31:
* OOP Design
* public / private
* public functions / private data

Part 32:
* OOP Encapsulation
* Types of variables / Instances of variables

Part 33:
* methods work exactly as functions
* ISO Standard C++
* Standard Library headers

Part 34:
* creating arrays
* offset zero
* array boundaries

Part 35:
* More on arrays
* standard string


Part 36:
* member variable scope in methods
* passing a int rvalue (literal constant) into a function
* problem of using uninitialized member variables

Part 37:
* (default) constructor
* making your own constructor
* passing to constructors
* initializer list

Part 38:
* OOP Encapsulation
* class declaration / definition
* methods & functions- same rules (pretty much)

Part 39:
* class declarations in headers, definitions in source files.

Part 39:
* source files are separate entities
* header files for declaration
* linker to the rescue

Wrap 1 at video 40:
* some corrections
* comments

Wrap 2 at video 40:
* more on comments
* more on passing into functions
* more on returning from functions


Wrap 3 at video 40:
* casting basic types
* name clashes

Wrap 4 at video 40:
* standard c++

Wrap 5 at video 40:
* passing custom types
* returning custom types
* class scope

Wrap 6 at video 40:
* warning - stay tuned

Wrap 7 at video 40:
(testing YouTube HQ at 640x480)
* cross-referencing c++ concepts

Part 42 update 1:
* variables in RAM
* memory addresses

Part 43 update 1:
* address operator
* pointers

Part 44 update 1:
* using pointers
* overcoming scope


Part 45 update 1:
* more about pointers
* arrays are point Video tutorials about programming in the C++ programming language.
Part 45 update 1:
* more about pointers
* arrays are pointers
(This section confused me, seeing like you mentioned part 45 twice...)


Part 46:
* dangers of pointers

Part 47:
* more dangers of pointers

Part 48:
* heap memory allocation

Part 49:
* 'delete'ing heap memory
* bypassing scope by passing memory address

Part 50:
* more about 'delete'ing
* vital advice about heap memory

Part 51:
* more heap-memory ugliness
* OOP insight


Part 52:
* const/non-const pointers to const/non-const variables


Part 53:
* const/non-const pointers to const/non-const variables
* write protection with const

Hey thanks! Ya I was always pushing off finishing this list... thanks a lot Doctor Salt!

(p.s. no ungratefulness taken )

Woah! Looked like that saved him some work.

Nice job Salt!

Hmm, just a little thing about your videos: You probably already know this, but with the url address of each of your tutorials, if you add on
"&fmt=18" without quotes, to the end of it, it will display the same video, but in high definition,so you could actually pull off doing your vids in a higher resolution, and still be comprehensible.

ex. You turn

http://www.youtube.com/watch?v=pZTMBOBt-HQ

into

http://www.youtube.com/watch?v=pZTMBOBt-HQ&fmt=18

Good idea! Thanks!

no problem! even though i only got to like video 40, when getting all the video descriptions, i noticed on video

Wrap 7 at video 40:
(testing YouTube HQ at 640x480)
* cross-referencing c++ concepts

you tried going back to high resolution, but then after that, you switched back. Maybe the whole &ftm=18 thing will let you do that again.....

i was reading some where that ,that only works for videos that were specified to be high quality , so antiRTFM is still going to have to upload the vids and choose high quality or it wont work , but yeah that is the extension for higher quality movies on youtube( if available).

and good job doctorsalt . you made things easier for alot of us

Hehehehe, the way i see it, this is the way for me to be morally balanced when asking you guys questions and you people using your own time and dedication to answer them!

rooski wrote:i was reading some where that ,that only works for videos that were specified to be high quality , so antiRTFM is still going to have to upload the vids and choose high quality or it wont work , but yeah that is the extension for higher quality movies on youtube( if available).

and good job doctorsalt . you made things easier for alot of us

Actually, what happens is that YouTube converts all the videos into HD, so no matter if your videos look a bit shoddy, YouTube is supposed to also make an HD version.

well they cant make a video look anybetter than the quality it is uploaded in , becuase that is impossible unless you edit it slightly , so if you upload a crappy quality video the best you will get out of it is a crappy video.