What is a Comment?

Comments in programming are text notes that programmers include in their code to explain its purpose or make it easier to understand.

• They are not executed by the computer and are intended for other developers.
• Comments improve code readability and help with debugging and collaboration.

There are two types of comments in C++ programming

1. Single line comment
2. Multi-line comment

Let’s discuss each of these comment types with examples.

1. Single-line C++ comments

Single-line comments in C++ are denoted by double slashes (//). Any text that follows the double slashes on the same line is considered a comment and is ignored by the compiler.

#include <iostream>

using namespace std;

int main()
{
    // This is a single line comment
    cout<<"Hello!";  // welcome message
    
    return 0;
}

In the above code line number 7 is a single-line comment. We can also write code and comment in a single line as shown in line number 8.

cout<<"Hello!";  // welcome message

Let’s see another example of the factorial of a number.

// Calculate the factorial of a given number using recursion
int factorial(int n) {
    if (n <= 1) {
        return 1; // Factorial of 0 and 1 is 1
    }
    else {
        return n * factorial(n - 1); // Recursive calculation
    }
}

Here line number 1,3 and 6 contains single line comment.

2. Multi-line C++ comments

In C++, multiline comments are used to add explanatory or descriptive text within the code. They start with /* and end with */, allowing multiple lines of comments. These comments are ignored by the compiler and are used for documentation purposes.

Here is an example of multi-line comment in C++.

#include <iostream>

using namespace std;

int main()
{
    /*
    This is a 
    multi line comment 
    used in C++ programminga
    */
    cout<<"Hello!";
    
    return 0;
}

Here line number 7 to 11 are multi-line comment.

Doxygen Style Comments

Doxygen is a documentation generator tool used to generate documentation for software projects. It extracts information from source code and generates various types of documentation, including HTML, PDF, and XML. It helps developers communicate and share information about their code.

Single-line comments

To add a doxygen-style single-line comment in C++, you can use the /// syntax before the comment. For example:

/// This is a doxygen-style single line comment.

Multi-line comments

Multi-line comments comment starts with “/*“, and ends with “*/“. We can write a doxygen-style multi-line comment as shown below :

/** * This is a Doxygen-style multi-line comment in C++. 
* It is commonly used to provide documentation for functions, classes, and variables. 
* The comment starts with "/**", ends with "*/", and can be used to generate documentation using Doxygen tool. 
*/

Commenting Guidelines

It is best to consider the following points when commenting.

• Be concise: Keep comments brief and to the point.
• Explain why, not what: Explain why we selected a particular approach.
• Update comments: As code evolves, remember to update or remove outdated comments that no longer reflect the code’s functionality.
• Avoid redundant comments: Don’t comment on every line. If it is necessary then write the comment.
• Use consistent style: Follow a consistent commenting style throughout your codebase for a polished look.

Conclusion

In conclusion, we have learned to write C++ comments in code. You can read about How To Get the Type of a Variable in Cpp.

The post CPP Comments appeared first on NoloWiz.

The typeid operator allows us to determine the type of variable/object at runtime.

The syntax of typeid operator

typeid ( type )

typeid ( expression )	

Parameters:

Typeid operator accepts one parameter :

• Type – Variable or object.
• Expression – Any valid expression.

Returns:

The typeid operator returns an lvalue of type const std::type_info that represents the type of expression.

To use the typeid operator we must include the STL header<typeinfo>.

Examples

Let’s check a number variable.

#include <iostream>
#include <typeinfo>

int main() {

    int a = 20;
    auto b = a * 2 ;
    std::cout << "b has type -> "<<typeid(b).name()<<"\n";
    
    return 0;
}

Output

b has type -> i

Let’s check a string variable.

#include <iostream>
#include <string>
#include <typeinfo>

int main() {

    std::string message = "Hello from NoloWiz";
    std::cout << message <<"\n";
    std::cout << "message has type -> "<<typeid(message).name()<<"\n";
    
    return 0;
}

Output

Hello from NoloWiz
message has type -> NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE

Let’s check a float pointer.

#include <iostream>
#include <typeinfo>

int main() {

    float* percentage = nullptr;
    std::cout << "percentage has type -> "<<typeid(percentage).name()<<"\n";
    
    return 0;
}

Output

percentage has type -> Pf

Non-polymorphic object

#include <iostream>
#include <typeinfo>

struct Base {}; 
struct Derived : Base {};

int main() {

    Derived drv;
    Base& base = drv;
    std::cout << "Reference to non-polymorphic base: " << typeid(base).name() << '\n';
    
    return 0;
}

Output

Reference to non-polymorphic base: 4Base

Polymorphic object

So what about the polymorphic object? let’s check that.

#include <iostream>
#include <typeinfo>

struct Base { virtual void foo() {} }; //polymorphic
struct Derived : Base {};

int main() {

    Derived drv;
    Base& base = drv;
    std::cout << "Reference to polymorphic base: " << typeid(base).name() << '\n';
    
    return 0;
}

Output

Reference to polymorphic base: 7Derived

Expression as parameter

Let’s pass an expression as a parameter to typeid.

#include <iostream>
#include <typeinfo>

int main() {

    int abc = 42;
    
    const std::type_info& typeInfo = typeid((10 + abc) / 2.0);
    std::cout <<"Type of expression (10 + abc) / 2.0 : "<<typeInfo.name();
    
    return 0;
}

Output

Type of expression (10 + abc) / 2.0 : d

The post How To Get the Type of a Variable in Cpp appeared first on NoloWiz.

My goal is to explore whether there’s a way we can evolve C++ itself to become 10x simpler, safer, and more toolable. If we had an alternate C++ syntax, it would give us a “bubble of new code that doesn’t exist today” where we could make arbitrary improvements (e.g., change defaults, remove unsafe parts, make the language context-free and order-independent, and generally apply 30 years’ worth of learnings), free of backward source compatibility constraints.

-Herb Sutter

In Cppfront we have two options :

• Write mixed Cpp1/Cpp2 in the same source file with perfect backward source compatibility via #include or import
• Write only Cpp2 in a particular source file and program in a 10x simpler C++, where code is type-safe and memory-safe by construction, keeps perfect backward link compatibility via import, and in the future (if Cppfront succeeds) with faster compilers and better tools tuned for the simpler language.

Herb Sutter suggests it would be nice to have the following features in C++

• less complexity to remember;
• with fewer safety gotchas; and
• the same level of tool support that other languages enjoy.

CPP2 syntax focus on the following areas:

• fix defaults (e.g., make [[nodiscard]] the default);
• double down on modern C++ (e.g., make C++20 modules and C++23 import std; the default);
• remove unsafe parts (e.g., remove union and pointer arithmetic);
• have type and memory safety by default (e.g., make the C++ Core Guidelines safety profiles the default and required);
• eliminate 90% of the guidance we have to teach about today’s complex language;
• make it easy to write a parser (e.g., have context-free grammar); and
• make it easy to write refactoring and other tools (e.g., have order-independent semantics)

Let’s try Cppfront.

Build Cppfront compiler

I used Ubuntu 22.04 first we need to install g++-10

sudo apt-get update
sudo apt install g++-10

Next clone the Cppfront repository.

git clone https://github.com/hsutter/cppfront.git

Enter into the “sources” directory and run the following command to build Cppfront:

g++-10 cppfront.cpp -std=c++20 -o cppfront

It will build the Cppfront executable.

Write some CPP2 code, build and run

Let’s write a hello world program using CPP2 syntax.

Open your favorite text editor and write the following code :

main: () -> int = {
 std::cout << "Hello world CPP2\n"; 
}

Save it as helloworld.cpp2, then run:

cppfront helloworld.cpp2

It will produce a helloworld.cpp file now we can compile it using the following command(Please note that we need to include cpp2util.h’s path ):

g++-10 helloworld.cpp -std=c++20 -I/home/rupesh/cppfront/include -o helloworldapp

Now run ./helloworld it will print “Hello world CPP2”.

One more example in pure cpp2

main: () -> int = {
    std::cout << "Hello " << name() << "\n";
}

name: () -> std::string = {
    s: std::string = "NoloWiz";
    decorate(s);
    return s;
}

decorate: (inout s: std::string) = {
    s = "[" + s + "]";
}

Compile and run :

./cppfront greetings.cpp2 -p
g++-10 greetings.cpp -std=c++20 -I/home/rupesh/cppfront/include -o greetings
./greetings

More examples are available here.

The post Cppfront – A new Syntax for CPP appeared first on NoloWiz.

1.Using the getline function

The getline function can be used to split strings in C++.

istream& getline (istream&  is, string& str, char delim);

• is : Extact string from istream object
• str : extracted line string
• delim : delimiter character

#include <iostream>
#include <sstream>
#include <vector>

using namespace std;

void splitstring(const string &str, 
                 char delimiter,
                 vector<string>& tokens)
{
    stringstream ss(str); //Create stringstream object
    string word;// to store the token (splitted string)

    while(getline(ss,word,delimiter).good())
    {
        tokens.push_back(word);
    }
    if (tokens.size()>0)
       tokens.push_back(word); // insert last token
}

int main()
{

    string str="car,bike,bus,bicycle";
    vector<string> vec;
    splitstring(str,',',vec);

    for(auto s:vec)
    {
        cout<<s<<"\n";
    }
    return 0;
}

Output

car
bike
bus
bicycle

To split the string, we will extract individual words/tokens in the string using getline function and inserts extracted tokens into a vector.

2.Using the std::regex_token_iterator function

We can use std::regex_token_iterator function to split string in C++11.

#include <iostream>
#include <vector>
#include <regex>

using namespace std;

void splitstring(string &str,
                 regex re,
                 vector<string>& tokens)
{
    string word;// to store the token (splitted string)
    regex_token_iterator<string::iterator>  it( str.begin(), str.end(), re, -1 );
    regex_token_iterator<string::iterator> rend;

    while( it!=rend )
    {
        word = *it++;
        if (word !=  str)
            tokens.push_back(word);
    }
}

int main()
{

    string str="car,bike,bus,bicycle";
    std::regex regex("\\,");
    
    vector<string> tokens;
    splitstring(str,regex,tokens);

    for(const auto v :tokens)
    {
        cout<<v<<"\n";
    }

    return 0;
}

Output

car
bike
bus
bicycle

3.Using the std::strtok function

A sequence of calls to std::strtok function will give us tokens. Please note that this function uses C strings.

#include <iostream>
#include <vector>
#include <stdio.h>
using namespace std;

void splitstring(const string &str,
                 const char *delimiter,
                 vector<string>& tokens)
{
    string word;// to store the token (splitted string)

    char* ptoken = strtok(const_cast<char*>(str.c_str()),delimiter);
    while(ptoken!=nullptr)
    {
       word = string(ptoken);
       if (word != str)
           tokens.push_back(word);

       ptoken = strtok(nullptr,delimiter);
    }
}

int main()
{

    string str="car,bike,bus,bicycle";
    
    vector<string> tokens;
    splitstring(str,",",tokens);

    for(const auto v :tokens)
    {
        cout<<v<<"\n";
    }

    return 0;
}

Output

car
bike
bus
bicycle

4.Using the std::string::find function

In this method, we will use the string::find function to search the delimiter. Find function will return the position of the separator and we can create tokens from it. We will use string::find and string::substr for tokenization. Here string::npos is used as an error indicator.

#include <iostream>
#include <vector>

using namespace std;

void splitstring(const string &str,
                 char delimiter,
                 vector<string> &tokens)
{
    string word; // to store the token (splitted string)

    size_t offset = 0, count;

    size_t pos = str.find(delimiter);
    while (pos != string::npos)
    {
        count = pos - offset;
        word = str.substr(offset, count);
        tokens.push_back(word);

        offset = pos + 1;
        pos = str.find(delimiter, pos + 1);
    }

    if (tokens.size() > 0)
    {
        word = str.substr(offset);
        tokens.push_back(word);
    }
}
int main()
{

    string str = "car,bike,bus,bicycle";
    vector<string> tokens;
    splitstring(str, ',', tokens);

    for (auto v : tokens)
    {
        cout << v << "\n";
    }

    return 0;
}

5.Split string in C++ using boost::split

In this method, we will use boost library for string splitting. we will use the boost::split function to split the string.

#include <iostream>
#include <vector>
#include <boost/algorithm/string.hpp>

using namespace std;
 
int main() {
	string str("car,bike,bus,bicycle");

    vector<string> tokens;
    boost::split(tokens, str, boost::is_any_of(","));
 
    for(auto v: tokens )
       cout<< v <<"\n";

	return 0;
}

The post Split Strings in C++ appeared first on NoloWiz.

The std::string::npos is a static member constant. It is defined in the string (basic_string.h) header file.

///  Value returned by various member functions when they fail.
static const size_type	npos = static_cast<size_type>(-1);

It is a static member constant with the maximum value representable by the type size_type. The type of size_type is unsigned integer however it is initialized as -1 but due to signed to unsigned implicit conversion, it will hold the largest positive value. This is a portable way to specify the maximum value of any unsigned type.

Let’s print the value of string::npos.

#include <iostream>
using namespace std;

int main() {
	cout<<string::npos<<endl;
	return 0;
}

Output

18446744073709551615

Here 18446744073709551615 is the maximum value of unsigned 64-bit number 2⁶⁴ -1 (on a 64-bit platform).

However,the string::npos generally used in the following cases

• end of string indicator by functions that expects a string index.
• error indicator for functions that returns a string index.

Let’s look into these two cases with examples.

Using it as end of string indicator

Firstly we will look into npos as the end of string indicator.

#include <iostream>
using namespace std;
 
int main() {
    string str = "hello";
    string s2(str,3,string::npos); // npos to indicate end of the string
     
    cout<<s2<<"\n";
     
    return 0;
}

Output

lo

Using it as error indicator

In this case, the string::npos is used as the return value from the string find function. If no match found string find function will return string::npos.

#include <iostream>
using namespace std;

int main() {
    string str = "hello";
    
    if(str.find('w') == string::npos)
        cout << "w not found\n";
        
	return 0;
}

Output

w not found

Conclusion

In conclusion, the exact meaning of string::npos depends on the context. Hence, we can summarize as

• it is maximum value representable by size_type
• End of string indicator
• Error indicator

The post What is string::npos in C++? appeared first on NoloWiz.

So what is pure virtual function?

A pure virtual function is a function,

• that must be overriden in the derived class
• need not to be defined

A virtual function can be declared “pure” using the =0 (pseudo initializer).

Example of pure virtual function declaration

class Base{
   public:
    virtual void f3() =0; //pure virtual function
};

Abstract class and pure virtual function

An abstract class has at least one pure virtual function. We cannot instantiate(create a new object) of an abstract class.

class Base{
   public:
    void f1(); // function
    virtual void f2(); //virtual function
    virtual void f3() =0; //pure virtual function
};

Base b; //  error : pure virtual function f3 not overriden

Here “Base” class is an abstract class because it has a pure virtual function f3. The derived class must override the pure virtual function of the base class.

 class Derived : public Base {
        // no f1: fine
        // no f2: fine, we inherit Base::f2
        void f3();// Overriden pure virtual function
    };
 Derived d; //Ok

Here f3 is overridden hence we can create an object of Derived.

What happens if we don’t override pure virtual function?

If we don’t override pure virtual function in a derived class it will become an abstract class.

class D2 : public Base {
        // no f1: fine
        // no f2: fine, we inherit Base::f2
        // no f3: fine, but D2 is therefore still abstract
    };

 D2 d;   // error: pure virtual Base::f3 not overridden

Here we cannot create an instance of D2 because D2 didn’t override the pure virtual function so it becomes an abstract class.

Conclusion

In conclusion, we can summarize the following points

• To declare pure virtual function use the “pseudo initializer” =0.
• A class with one or more pure virtual functions is an abstract class.
• Pure virtual functions must be overriden by derived class.
• If we dont override pure virtual function in derived class it will become an abstract class.

The post All About Pure Virtual Functions in C++ appeared first on NoloWiz.

Using the cin to read string input

In this example, we will use cin object to read strings. The cin is an istream object.

#include <iostream>

using namespace std;

int main()
{
    cout << "Please enter your name: ";

    string name;
    cin>> name;

    cout << "Hello " << name <<"!"<<endl;

    return 0;
}

Output

Please enter your name: Tom
Hello Tom!

Note that there is no explicit memory management and no fixed-size buffer to overflow.

Using the getline to read string

Let’s use getline function to read string input.

//Get line from stream into string
istream& getline (istream& is, string& str);

is : the istream object from which characters are extracted.

str : string object where the extracted line is stored.

Let’s look into an example.

#include <iostream>

using namespace std;

int main()
{
    cout << "Please enter your name: ";

    string name;
    getline(cin,name);

    cout << "Hello " << name <<"!"<<endl;

    return 0;
}

Output

Please enter your name: Bob
Hello Bob!

The post Reading String From Input in C++ appeared first on NoloWiz.

Destructor is part of Resource Acquisition Is Initialization(RAII) programming idiom. The basic idea of RAII is constructor will acquire(allocate) resources and the destructor will release resources for a class. The most common example of a destructor is when the constructor uses new, and the destructor uses delete.

Destructors are also known as “prepare to die” member functions. They have often abbreviated “dtor”. Now let’s dive into virtual destructors.

When to use virtual destructors?

When we want to delete polymorphically we can use a virtual destructor. In other words, virtual destructors are useful when we want to delete an instance of a derived class through a pointer to the base class.

Let’s understand it with an example. Consider base class without destructor.

#include <iostream>

using namespace std;

class Base{
public:
     ~Base(){ cout<<"Base destructor"<<endl; }

};

class Derived : public Base{
public:
    ~Derived(){ cout<<"Derived destructor"<<endl; }
};

int main()
{
    Base *pBase=new Derived();
    delete pBase;
    return 0;
}

Output

Base destructor

Here only base class destructor called, derived class destructor not called and as a result resource will not be released( Here we are only printing for sake of simplicity). To solve this issue we can use a virtual destructor.

virtual ~Base(){ cout<<“Base destructor”<<endl; }

// Virtual destructor example

#include <iostream>

using namespace std;

class Base{
public:
    virtual ~Base(){ cout<<"Base destructor"<<endl; }

};
class Derived : public Base{
public:
    ~Derived(){ cout<<"Derived destructor"<<endl; }
};

int main()
{
    Base *pBase=new Derived();
    delete pBase;
    return 0;
}

Output

Derived destructor
Base destructor

From this, we can see first the derived class destructor is called the base class destructor.

Conclusion

In conclusion, a base class destructor should be virtual if we are going to delete polymorphically ( delete via a pointer to base).

The post Virtual Destructors in CPP appeared first on NoloWiz.

We will be using a 64-bit machine to compile the test code. For a 64-bit machine, the pointer size is 8 bytes.

Size of empty class

The size of an empty c++ class is 1 byte. It is to ensure that the addresses of two different objects will be different.

#include <iostream>

using namespace std;

class empty{
};

int main()
{
    cout<< "Size of empty class : "<<sizeof(empty)<<endl;
    return 0;
}

Output

Size of empty class : 1

Class with a member function

Let’s consider a class with one member function.

#include <iostream>

using namespace std;

class Shape{
public:
    void draw(){cout <<"shape";}
};

int main()
{
    cout<< "Size of shape class : "<<sizeof(Shape)<<endl;
    return 0;
}

Output

Size of shape class : 1

So adding member functions doesn’t change the class size. What about virtual functions?

Class with virtual function

Let’s consider a class with a virtual function. Do you think its size is still 1 byte?

#include <iostream>

using namespace std;

class Shape{
public:
    virtual void draw(){cout <<"shape";}
};

int main()
{
    cout<< "Size of shape class with virtual function : "<<sizeof(Shape)<<endl;
    return 0;
}

Output

Size of shape class with virtual function : 8

For classes with virtual functions, the compiler will add a hidden pointer known as a virtual pointer(VPTR). The size of a pointer is in a 32-bit platform is 4 bytes. Here we are using the 64-bit machine so it is 8 bytes.

Class with data members

Let’s consider a class with member variables.

#include <iostream>

using namespace std;

class Shape{
public:
    int a;
};

int main()
{
    cout<< "Size of shape class with data member : "<<sizeof(Shape)<<endl;
    return 0;
}

Output

Size of shape class with data member: 4

Here the size of the class changed based on the data type of the member variable. The int data type will take 4 bytes of memory.

Conclusion

In conclusion, we can summarize the size of C++ classes as

• The Size of empty class : 1 byte
• Size of class with member function(s) : 1 byte
• Size of class with virtual functions : 8 bytes on 64-bit platform or 4 bytes on 32-bit platform

The post Size of C++ classes appeared first on NoloWiz.

C++ is a compiled language. Firstly, the compiler processes the source code files and produces object files. The linker will combine these object files to yield an executable program.

Let’s look into the smallest C++ program

int main() {}

This shortest program has a main() function it takes no arguments and does nothing. The curly brackets {} express the grouping in C++. Here it is used to start and end the main function.

As per the C++ standard, every C++ program must have exactly one global main function. The program starts executing this main() function.

The main function will return an int value. The program will return this value to the “system”. A non-zero value indicates the failure. Linux/Unix-based environments often make use of this returned value and Windows environments rarely use it.

Let’s compile and run this program

g++ -o shortest shortest_program.cpp
./shortest

The program displays nothing, let us check the returned value.

./shortest
echo $?
0

From the above output, we can see that it returns 0.

Let’s disassemble this program and see the instructions. Yes, it is not that small :).

g++ -S -o shortest.s shortest_program.cpp

	.file	"shortest_program.cpp"
	.text
	.globl	main
	.type	main, @function
main:
.LFB0:
	.cfi_startproc
	endbr64
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	movl	$0, %eax
	popq	%rbp
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 11.2.0-7ubuntu2) 11.2.0"
	.section	.note.GNU-stack,"",@progbits
	.section	.note.gnu.property,"a"
	.align 8
	.long	1f - 0f
	.long	4f - 1f
	.long	5
0:
	.string	"GNU"
1:
	.align 8
	.long	0xc0000002
	.long	3f - 2f
2:
	.long	0x3
3:
	.align 8
4:

That’s all about the shortest C++ program.

The post Shortest C++ Program appeared first on NoloWiz.