Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision 		Previous revision
c [2019/03/01 20:26]
127.0.0.1 external edit 		c [2020/10/23 02:53] (current)
Line 1: Line 1:
 ====== C and C++ ====== ====== C and C++ ======
 +
 +===== C declerations =====
 +
 +A c decleration can be read by following this rule and knowing about precedence.
 +
 +Go left when you can and right when you must.
 +
 +<code>
 +char *(*(**foo [][8])())[];
 +</code>
 +
 +foo is an array to an array of 8 pointers to poiners to a function that returns
 +a pointer to an array of pointers to char
 +
 +===== C++ Interview questions =====
 +
 +I was given a pop quiz by a non-tech interviewer once on c++. Here was his questions:
 +
 +  - What is the name of an invalid pointer? 
 +      - Weird question and I don't think it's right. Answer he was looking for was null.
 +  - What is the difference between a struct and a class? 
 +  - What is the keyword to deallocate memory? Lol
 +  - When using a new keyword where is the memory stored, stack or heap? Heap OBVI.
 +  - If a program crashes and you have a core dump and debugger, what is the first thing you do? 
 +      - Look at a backtrace, see where the program crashed, look at what the variable were.
 +===== General C++ ===== 
 +
 +Principles of C++: (([[https://www.grimm-jaud.de/images/stories/pdfs/c%2B%2B11_AnOverview.pdf|Rainer Grimm's C++ 11 overview]]))
 +  * Trust the programmer.
 +  * You don't have to pay for something you don't need.
 +  * Don't break existing code.
 +  * Prefer compile time errors over run time errors.
  
 ===== Differences Between C and C++ ===== ===== Differences Between C and C++ =====
Line 72: Line 104:
 This way you can use a macro expansion in a if else statement with no curly braces This way you can use a macro expansion in a if else statement with no curly braces
 where more than one statement would mess stuff up. where more than one statement would mess stuff up.
 +
 +===== C Declerations =====
 +
 +First, understand the breakdown of a decleration in c.
  
 ===== Rule of Three ===== ===== Rule of Three =====
Line 111: Line 147:
  
 An ''%%std::deque%%'' is double ended array that can grow from each end. An ''%%std::deque%%'' is double ended array that can grow from each end.
 +
 +==== Pair ====
 +
 +An ''%%std::pair%%'' is an object that holds a pair of objects.
 +
 +<code cpp>
 +// pair::pair example
 +#include <utility>      // std::pair, std::make_pair
 +#include <string>       // std::string
 +#include <iostream>     // std::cout
 +
 +int main () {
 +  std::pair <std::string,double> product1;                     // default constructor
 +  std::pair <std::string,double> product2 ("tomatoes",2.30);   // value init
 +  std::pair <std::string,double> product3 (product2);          // copy constructor
 +
 +  product1 = std::make_pair(std::string("lightbulbs"),0.99);   // using make_pair (move)
 +
 +  product2.first = "shoes";                  // the type of first is string
 +  product2.second = 39.90;                   // the type of second is double
 +
 +  std::cout << "The price of " << product1.first << " is $" << product1.second << '\n';
 +  std::cout << "The price of " << product2.first << " is $" << product2.second << '\n';
 +  std::cout << "The price of " << product3.first << " is $" << product3.second << '\n';
 +  return 0;
 +}
 +</code>
  
 ==== List ==== ==== List ====
Line 139: Line 202:
 function. function.
  
-<code c++>+<code cpp>
 std::map<int, std::string> myMap; std::map<int, std::string> myMap;
 myMap.insert(std::make_pair(1, "mango")); myMap.insert(std::make_pair(1, "mango"));
Line 145: Line 208:
  
 ===== Memory Leaks ===== ===== Memory Leaks =====
 +
  
 For every new there must be a delete. Use the following valgrind command to For every new there must be a delete. Use the following valgrind command to
Line 151: Line 215:
 <code bash> <code bash>
 valgrind --tool=memcheck --leak-check=yes name_of_exec valgrind --tool=memcheck --leak-check=yes name_of_exec
 +</code>
 +
 +===== Lambda Functions ======
 +
 +Lambda functions are:
 +  * functions without a name
 +  * define their functionality right in place
 +  * can be copied like data
 +
 +Lambda functions should be precise and self explaining.
 +
 +The syntax is as follows:
 +
 +{{::screenshot_2019-03-13_17-07-19.png?400|}}
 +  * [] : captures the used variables per copy of per reference
 +  * () : is required for parameters
 +  * -> : is required for a return value
 +  * {} : may include expressions and statements
 +
 +===== Range-based for statement =====
 +
 +C++ 11 introduced the range-based ''%%for%%'' statement (([[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3690.pdf|Section 6.5.4 c++ 11 standard]])) and takes the form:
 +<code>
 +for ( for-range-declaration : expression ) statement
 +</code>
 +
 +Example:
 +<code cpp>
 +int array[5] = { 1, 2, 3, 4, 5 };
 +for (int& x : array)
 +    x *= 2;
 </code> </code>
  
Line 173: Line 268:
 For macros see the following [[https://sourceware.org/gdb/onlinedocs/gdb/Macros.html|link]]. For macros see the following [[https://sourceware.org/gdb/onlinedocs/gdb/Macros.html|link]].
  
-~~DISCUSSION~~+ 
 +===== Mutable ===== 
 + 
 +''%%mutable%%'' permits modification of the class member declared mutable even if the containing object is declared const. 
 +<code cpp> 
 +int main() 
 +{ 
 +    int n1 = 0;           // non-const object 
 +    const int n2 = 0;     // const object 
 +    int const n3 = 0;     // const object (same as n2) 
 +    volatile int n4 = 0;  // volatile object 
 +    const struct 
 +    { 
 +        int n1; 
 +        mutable int n2; 
 +    } x = {0, 0};      // const object with mutable member 
 +  
 +    n1 = 1; // ok, modifiable object 
 +//  n2 = 2; // error: non-modifiable object 
 +    n4 = 3; // ok, treated as a side-effect 
 +//  x.n1 = 4; // error: member of a const object is const 
 +    x.n2 = 4; // ok, mutable member of a const object isn't const 
 +  
 +    const int& r1 = n1; // reference to const bound to non-const object 
 +//  r1 = 2; // error: attempt to modify through reference to const 
 +    const_cast<int&>(r1) = 2; // ok, modifies non-const object n1 
 +  
 +    const int& r2 = n2; // reference to const bound to const object 
 +//  r2 = 2; // error: attempt to modify through reference to const 
 +//  const_cast<int&>(r2) = 2; // undefined behavior: attempt to modify const object n2 
 +} 
 +</code> 
 +Output: 
 +<code> 
 +# typical machine code produced on an x86_64 platform 
 +# (only the code that contributes to observable side-effects is emitted) 
 +main: 
 +    movl    $0, -4(%rsp) # volatile int n4 = 0; 
 +    movl    $3, -4(%rsp) # n4 = 3; 
 +    xorl    %eax, %eax   # return 0 (implicit) 
 +    ret 
 +</code> 
 + 
 +==== Pointer Syntax ==== 
 + 
 + 
 +<code cpp>sf::Sprite* re_sprite_hair, re_sprite_body, re_sprite_eyes;</code> 
 + 
 +Does not declare 3 pointers - it is one pointer and 2 objects. 
 + 
 +<code cpp> 
 +sf::Sprite* unfortunately does not apply to all the variables declared following it, just the first. It is equivalent to 
 + 
 +sf::Sprite* re_sprite_hair; 
 +sf::Sprite re_sprite_body; 
 +sf::Sprite re_sprite_eyes; 
 +</code> 
 + 
 +You want to do: 
 + 
 +<code cpp> 
 +sf::Sprite *re_sprite_hair, *re_sprite_body, *re_sprite_eyes; 
 +</code> 
 + 
 +===== Smart Pointers ===== 
 + 
 +The STL library provides three types of "smart pointers", %%std::unique_ptr%%, %%std::shared_ptr%% and %%std::weak_ptr%%. 
 + 
  • c.1551471961.txt.gz
  • Last modified: 2019/03/01 20:26
  • by 127.0.0.1