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/04/02 14:21]
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++ =====  ===== General C++ ===== 
  
Line 80: 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 124: Line 152:
 An ''%%std::pair%%'' is an object that holds a pair of objects. An ''%%std::pair%%'' is an object that holds a pair of objects.
  
-<code c++>+<code cpp>
 // pair::pair example // pair::pair example
 #include <utility>      // std::pair, std::make_pair #include <utility>      // std::pair, std::make_pair
Line 174: 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 180: 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 213: Line 242:
  
 Example: Example:
-<code c++>+<code cpp>
 int array[5] = { 1, 2, 3, 4, 5 }; int array[5] = { 1, 2, 3, 4, 5 };
 for (int& x : array) for (int& x : array)
     x *= 2;     x *= 2;
 </code> </code>
 +
 ===== Debugging ===== ===== Debugging =====
  
Line 237: Line 267:
  
 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]].
 +
 +
 +===== 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.1554214874.txt.gz
  • Last modified: 2019/04/02 14:21
  • by 127.0.0.1