C++ syntax (Java equivalent)
https://www.geeksforgeeks.org/storage-classes-in-c/
https://www.ntu.edu.sg/home/ehchua/programming/cpp/cp3_OOP.html
https://www.ntu.edu.sg/home/ehchua/programming/index.html
In Java, it is called generics.
Purpose is to create a reusable class that allows variable typing while having the same methods.
a->b is, originally, a shorthand notation for (*a).b.
However, -> is the only of the member access operators that can be overloaded, so if a is an object of a class that overloads operator-> (common such types are smart pointers and iterators), then the meaning is whatever the class designer implemented. To conclude: With a->b, if a is a pointer, b will be a member of the object the pointer a refers to. If, however, a is an object of a class that overloads this operator, then the overloaded operator function operator->() gets invoked.
In Java, it is similar to calling the class's method.
The :: is called scope resolution operator. Can be used like this:
:: identifier
class-name :: identifier
namespace :: identifier
https://docs.microsoft.com/en-us/cpp/cpp/scope-resolution-operator?view=vs-2017
This is a lambda expression in C++.
[ capture clause ] (parameters) -> return-type
{
definition of method
}
https://docs.microsoft.com/en-us/cpp/cpp/lambda-expressions-in-cpp?view=vs-2019
The difference is how the values are captured
int x = 1;
auto valueLambda = [=]() { cout << x << endl; };
auto refLambda = [&]() { cout << x << endl; };
x = 13;
valueLambda();
refLambda();
output will be
1
13
#include <iostream>
#include <string>
using std::string;
int main()
{
string str = "Example";
using std::cout;
cout << str;
}
#include <iostream>
struct B {
virtual void f(int) { std::cout << "B::f\n"; }
void g(char) { std::cout << "B::g\n"; }
void h(int) { std::cout << "B::h\n"; }
protected:
int m; // B::m is protected
typedef int value_type;
};
struct D : B {
using B::m; // D::m is public
using B::value_type; // D::value_type is public
using B::f;
void f(int) { std::cout << "D::f\n"; } // D::f(int) overrides B::f(int)
using B::g;
void g(int) { std::cout << "D::g\n"; } // both g(int) and g(char) are visible
// as members of D
using B::h;
void h(int) { std::cout << "D::h\n"; } // D::h(int) hides B::h(int)
};
int main()
{
D d;
B& b = d;
// b.m = 2; // error, B::m is protected
d.m = 1; // protected B::m is accessible as public D::m
b.f(1); // calls derived f()
d.f(1); // calls derived f()
d.g(1); // calls derived g(int)
d.g('a'); // calls base g(char)
b.h(1); // calls base h()
d.h(1); // calls derived h()
}
struct B1 { B1(int, ...) { } };
struct B2 { B2(double) { } };
int get();
struct D1 : B1 {
using B1::B1; // inherits B1(int, ...)
int x;
int y = get();
};
void test() {
D1 d(2, 3, 4); // OK: B1 is initialized by calling B1(2, 3, 4),
// then d.x is default-initialized (no initialization is performed),
// then d.y is initialized by calling get()
D1 e; // Error: D1 has no default constructor
}
struct D2 : B2 {
using B2::B2; // inherits B2(double)
B1 b;
};
D2 f(1.0); // error: B1 has no default constructor
https://en.cppreference.com/w/cpp/language/using_declaration
https://en.cppreference.com/w/cpp/keyword/using
User-Defined Type Conversions (C++)
By default when you create a user-defined conversion, the compiler can use it to perform implicit conversions. Sometimes this is what you want, but other times the simple rules that guide the compiler in making implicit conversions can lead it to accept code that you don't want it to.
#include <iostream>
class Money
{
public:
Money() : amount{ 0.0 } {};
Money(double _amount) : amount{ _amount } {};
double amount;
};
void display_balance(const Money balance)
{
std::cout << "The balance is: " << balance.amount << std::endl;
}
int main(int argc, char* argv[])
{
Money payable{ 79.99 };
display_balance(payable); // legal: no conversion required
display_balance(49.95); // legal: a temp value of type Money is constructed
display_balance(9.99f); // legal: compiler can perform a standard conversion
return 0;
}
With explicits,
#include <iostream>
class Money
{
public:
Money() : amount{ 0.0 } {};
explicit Money(double _amount) : amount{ _amount } {};
double amount;
};
void display_balance(const Money balance)
{
std::cout << "The balance is: " << balance.amount << std::endl;
}
int main(int argc, char* argv[])
{
Money payable{ 79.99 }; // Legal: direct initialization is explicit.
display_balance(payable); // Legal: no conversion required
display_balance(49.95); // Error: no suitable conversion exists to convert from double to Money.
display_balance((Money)9.99f); // Legal: explicit cast to Money
return 0;
}
https://docs.microsoft.com/en-us/previous-versions/wwywka61(v%3Dvs.140)
The auto keyword is simply asking the compiler to deduce the type of the variable from the initialization. template
We recommend that you use the auto keyword for most situations—unless you really want a conversion—because it provides these benefits:
https://docs.microsoft.com/en-us/cpp/cpp/auto-cpp?view=vs-2019
The decltype type specifier yields the type of a specified expression. The decltype type specifier, together with the auto keyword, is useful primarily to developers who write template libraries. Use auto and decltype to declare a template function whose return type depends on the types of its template arguments. Or, use auto and decltype to declare a template function that wraps a call to another function, and then returns the return type of the wrapped function.
int x = 5;
double y = 5.1;
decltype(x) foo; // int
decltype(y) bar; // double
decltype(x+y) baz; // double
https://docs.microsoft.com/en-us/cpp/cpp/decltype-cpp?view=vs-2019
When a variable is declared as reference, it becomes an alternative name for an existing variable. A variable can be declared as reference by putting ‘&’ in the declaration.
Modify the passed parameters in a function
If a function receives a reference to a variable, it can modify the value of the variable. For example, in the following program variables are swapped using references.
#include<iostream>
using namespace std;
void swap (int& first, int& second)
{
int temp = first;
first = second;
second = temp;
}
int main()
{
int a = 2, b = 3;
swap( a, b );
cout << a << " " << b;
return 0;
}
// Output: 3 2
Avoiding copy of large structures
Imagine a function that has to receive a large object. If we pass it without reference, a new copy of it is created which causes wastage of CPU time and memory. We can use references to avoid this.
In For Each Loops to modify all objects
We can use references in for each loops to modify all elements
#include <bits/stdc++.h>
using namespace std;
int main()
{
vector<int> vect{ 10, 20, 30, 40 };
// We can modify elements if we use reference
for (int &x : vect)
x = x + 5;
// Printing elements
for (int x : vect)
cout << x << " ";
return 0;
}
auto => will copy the vector, but we wanted a reference
auto& => will only bind to modifiable lvalues
const auto& => will bind to anything but make it const, giving us const_iterator
const auto&& => will bind only to rvalues
An lvalue (locator value) represents an object that occupies some identifiable location in memory (i.e. has an address).
rvalues are defined by exclusion, by saying that every expression is either an lvalue or an rvalue. Therefore, from the above definition of lvalue, an rvalue is an expression that does not represent an object occupying some identifiable location in memory.
An assignment expects an lvalue as its left operand, and var is an lvalue, because it is an object with an identifiable memory location. On the other hand, the following are invalid:
4 = var; // ERROR!
(var + 1) = 4; // ERROR!
Neither the constant 4, nor the expression var + 1 are lvalues (which makes them rvalues). They're not lvalues because both are temporary results of expressions, which don't have an identifiable memory location (i.e. they can just reside in some temporary register for the duration of the computation). Therefore, assigning to them makes no semantic sense - there's nowhere to assign to.
https://eli.thegreenplace.net/2011/12/15/understanding-lvalues-and-rvalues-in-c-and-c
Declaration of a pointer
int* ap; // It defines ap to be a pointer to an int.
void foo(int* p); // Declares function foo.
// foo expects a pointer to an int as an argument.
Dereference a pointer in an expression.
int i = 0;
int* ap = &i; // ap points to i
*ap = 10; // Indirectly sets the value of i to 10
A reference variable cannot be reassigned.
A pointer can be reassigned.
size_t is the unsigned integer type of the result of sizeof , alignof (since C11) and offsetof, depending on the data model.
class ApplicationUI : public QObject
In Java, its known as "extends".
It means that ApplicationUI inherits all methods and member variables from the class QObject. The use of public means that the public methods and members of QObject are also public in ApplicationUI.
Pointers and references are highly complex and difficult to master. But they can greatly improve the efficiency of the programs.
For novices, avoid using pointers in your program. Improper usage can lead to serious logical bugs. However, you need to understand the syntaxes of pass-by-reference with pointers and references, because they are used in many library functions.
https://www.ntu.edu.sg/home/ehchua/programming/cpp/cp4_PointerReference.html
Java's interface is C++'s abstract class.
// Java
interface Entity {
void func();
}
class EntityImpl implements Entity {
public void func() {
System.out.println("func()");
}
}
// C++
struct Entity {
virtual void func() = 0;
virtual ~Entity() {}
// just to emphasize it's a BASE class
protected: Entity() {} // not required
};
struct EntityImpl : Entity {
void func() {
std::cout << "func()" << std::endl;
}
};
It is the destructor. It gets called when you destroy (reaching end of scope, or calling delete to a pointer to) the instance of the object.
noexcept exists in two forms since C++11: as a specifier and as an operator. The C++ core guidelines uses the specifier.
By declaring a function, a method, or a lambda-function as noexcept, you specify that these does not throw an exception and if they throw, you do not care and let the program just crash. For simplicity reasons, I will write about function but mean also methods and function templates. There are various ways to express your intention:
void func1() noexcept; // does not throw
void func2() noexcept(true); // does not throw
void func3() throw(); // does not throw
void func4() noexcept(false); // may throw
The noexcept operator checks at compile-time if an expression does not throw an exception. The noexcept operator does not evaluate the expression. It can be used in a noexcept specifier of a function template to declare that the function may throw exceptions depending on the current type.
https://www.modernescpp.com/index.php/c-core-guidelines-the-noexcept-specifier-and-operator
It's the destructor. This method is called when the instance of your class is destroyed.
https://stackoverflow.com/questions/1395506/in-c-what-does-a-tilde-before-a-function-name-signify
The ~ operator is bitwise NOT, it inverts the bits in a binary number:
char b = 0xF0; /* Bits are 11110000 */
char c = ~b; /* Bits are 00001111 */
You can create an expression out of observable values and properties, and its result will also be an observable value. The result will stay updated when the expression’s operands change.
using namespace observable;
value<double> a = 5;
value<double> b = 15;
value<double> avg = observe((a + b) / 2);
b = 25; // The average is automatically updated.
You can also subscribe to changes and get notified when the avg changes.
avg.subscribe([](auto new_avg) { cout << new_avg << endl; };
https://danieldinu.com/posts/observable-c-expressions-using-the-observable-library/
They serve different purposes.
constexpris mainly for optimization whileconstis for practically const objects like value of Pi.
Both of them can be applied to member methods. Member methods are made const to make sure that there are no accidental changes by the method. On the other hand, the idea of using
constexpr is to compute expressions at compile timeso that time can be saved when code is run.
const can only be used with non-static member function whereas constexpr can be used with with member and non-member functions, even with constructors but with condition that argument and return type must be of literal types.
The motivation behind make_unique is primarily two-fold:
make_unique is safe for creating temporaries, whereas with explicit use of new you have to remember the rule about not using unnamed temporaries.
foo(make_unique<T>(), make_unique<U>()); // exception safe
foo(unique_ptr<T>(new T()), unique_ptr<U>(new U())); // unsafe*
The addition of make_unique finally means we can tell people to 'never' use new rather than the previous rule to "'never' use new except when you make a unique_ptr".
There's also a third reason:
make_unique does not require redundant type usage.
unique_ptr<T>(new T()) -> make_unique<T>()
None of the reasons involve improving runtime efficiency the way using make_shared does (due to avoiding a second allocation, at the cost of potentially higher peak memory usage).
The only difference between a
classand astructin C++ is thatstructshave defaultpublicmembers and bases and classes have defaultprivatemembers and bases. Both classes and structs can have a mixture ofpublic,protectedandprivatemembers, can use inheritance, and can have member functions.
I would recommend using structs as plain-old-data structures without any class-like features, and using classes as aggregate data structures with
privatedata and member functions.
// example about structures
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
struct movies_t {
string title;
int year;
} mine, yours;
void printmovie (movies_t movie);
int main ()
{
string mystr;
mine.title = "2001 A Space Odyssey";
mine.year = 1968;
cout << "Enter title: ";
getline (cin,yours.title);
cout << "Enter year: ";
getline (cin,mystr);
stringstream(mystr) >> yours.year;
cout << "My favorite movie is:\n ";
printmovie (mine);
cout << "And yours is:\n ";
printmovie (yours);
return 0;
}