Saturday, September 15, 2018

C ++ Programming Check List and three easy steps to be productive in C++ Programming Language.

How to be a Programmer in C++ language in a simple way.


To be productive in any language every programmer needs to know about important concepts. Let's try to find important concepts which every C++ Programmer needs to know about.

how to be a professional c++ developer
how to learn C++ to be a professional developer.


There are Three levels to be a  master in any programming language.

1. Low Level
2. Mid Level 
3. High Level 


Low Level:- 

Learn the fundamental things like variables, functions, arrays, it is really crucial to freely operate with pointers and references.
C++ doesn't have automatic garbage collection, which forces programmers to understand low-level details about memory management. In this context, knowing pointers is a must.
Compared to Java/C#, a confusing moment in C++ is that variables and members of type T actually hold T objects, rather then references to T.
An important role play rvalue and lvalue variables. with the new C++ standard (C++11 and beyond), move semantics come into play, allowing to write even more efficient code.

Finally, you can't code complex projects if you are not familiar with Classes and Objects, object construction/destruction procedures, and similar.
                    

Mid Level:- 

                  More in-depth knowledge of Object -Oriented C++ concepts are a must, knowing how virtual functions work, what is a virtual table pointer (sometimes referred as a vtable, vptr) and how would you describe the difference between static and dynamic polymorphism.
Speaking of static polymorphism, templates come to mind.
Getting to know the templates will come naturally if you will dive deeper into the Standard Template Library, STL. You should know the differences between std:: vector<T> and std:: list<T>, and why iterators are called "random access iterators" for vectors, and "bidirectional iterators" for lists.
                                               

High Level:-

                      While knowing containers and algorithms from the STL is a must for mid-level C++ developers, details of those algorithms/ containers implementations.
Here's a common C++ interview question you might encounter your career: "why is the time complexity of std:: distance() function O(n) for std:: list iterators, and O(1) for std:: vector iterators?"
Here's another one, "describe the ".
This question tests whether the developer knows that std:: remove returns an iterator to the beginning of the range of "not actually removed" elements, after which one should "really" remove those elements by calling the container-specific to erase() function. 

What we should learn in C++...

Data Hierarchy 
Memory Concepts 
Algorithms 
Pseudocode
Control Structures
        Sentinel-Controlled Repetition
        Nested Control Statements
Assignment Operators
Logical Operators
Different between (==) and (=) Operators
How to define Class
How to define function and data members in a class and out of the class
Function with parameter
Function prototype and Argument passing
Reference and reference parameters
Default arguments
Utility function
Reusability concept in program
How to use Objects with Constructors
If statement
If-else statement
while statement
Do-while statement
Increment and Decrement Operators
For loop 
Switch statement with Break and continue keywords
the erase-remove idiom in C++
Math library
Standard library
Storage classes
Variable Scope rules
Inline function
Unary scope resolution operator
Function overloading
Function templates
Recursion 
Declaration of an array using the loop 
Use of bar chart to display array data
Local and static local arrays
Range based statement

Multidimensional array
Pointer variable(initialization/declaration)

Passing references using a pointer
Nonconstant and constant pointer
Pointer Expression/Pointer Arithmetic
Relationship between pointer and array
Use of string using a pointer
Class scope
Destructors
Constant object
Constant data members of the class

Friend function/Friend class

This pointer

Static class/ static member

Operator Overloading

Overloading Binary Operators

Overloading Unary operators

Overloading the Unary prefix and postfix operator

Dynamic memory management

Operators as a member or non-member functions

Explicit constructors and Overloading the Function call operator ()

Base class and Derived class

Relationship between Base and Derived class

Constructors and Destructors in Derived classes

Access modifiers

Public, Private and Protected inheritance

Polymorphism

Virtual function and virtual destructors

Type fields

Abstract classes

Pure virtual functions

Streams
Classic and Standard streams
Iostream library headers
Input-output streams
Uppercase and Lowercase control
Files and Stream
Creating a sequential file
Reading data from a file
Updating file
Random access file
Creating, reading, writing data to a random access file
Iterators
Class bitset
Exception handling
Rethrowing an exception
Stack Unwinding
Dynamic Memory allocation
Standard library exception hierarchy
Nontype parameters
Overloading function templates
Self-refer classes
Typedef keyword
Typeof keyword
Namespaces
Multiple Inheritance
Preprocessing directive
Symbolic constant
Macros
Conditional Compilation
# and ## Operators
Assertions

and most important is that you learn where a breakpoint occurs and when and how code run, stop and continue.

To read this post you think that you learn something new then please share this post and for any question please comment on the section given below.

Thank you....................

0 comments: