The truth is, you cannot truly learn programming without writing code. It is through this process that you learn new things and discover how small errors, like missing a quote or space, can frustrate you for hours.

No course can teach you the intricacies of Python the way finding and solving errors does.

That's why coding challenges are important if you are starting your coding journey. They help you implement your knowledge in practice and boost your confidence.

So to help you start coding more, here are eight Python challenges you can try as a beginner.

And here's a tip: really try to solve the challenge on your own after reading through the question/prompt. If you get stuck, then you can look at the code below and the explanation to help you figure it out.

Here Are the Challenges:

1. Python Challenge #1: Check if a List is Sorted
2. Python Challenge #2: Convert Binary number to decimal
3. Python Challenge #3: Loves Me, Loves Me Not
4. Python Challenge #4: The Tribonacci Sequence Challenge
5. Python Challenge #5: Hide a Credit Card Number
6. Python Challenge #6: SpongeCase
7. Python Challenge #7: Caesar Encryption
8. Python Challenge #8: Is the Product Divisible by the Sum?

All of these challenges help you in enhancing your problem-solving and algorithmic thinking skills. You'll also gain experience with writing and testing code to ensure correctness and efficiency.

Python Challenge #1: Check if a List is Sorted

The challenge: Write a function that checks whether a given list of numbers is sorted in either ascending or descending order.

Here's the code solution:

def is_sorted(lst):
    asc, desc = True, True
    for i in range(len(lst) - 1):
        if lst[i] > lst[i + 1]:
            asc = False
    for i in range(len(lst) - 1):
        if lst[i] < lst[i + 1]:
            desc = False
    return asc or desc

Code explanation:

In the above code, we define a function is_sorted that takes in a list as a parameter. We initialize two booleans, asc (for ascending) and desc (for descending) to True.

We then iterate through the list. If the ith element of the list is greater than the (i+1)th element, the asc flag is set to False, indicating that the list is not sorted in ascending order.

Then we iterate through the list again. If the ith element of the list is smaller than the i+1 th element, the desc flag is set to False, indicating that the list is not sorted in descending order.

If any element is found to be greater than the next element, the asc flag is set to False. Within the loop, we check to see if the ith element of the list is greater than the i+1 th element.

for i in range(len(lst) - 1):
    if lst[i] < lst[i + 1]:
        desc = False

We return True if either asc or desc is True. This means that the list is sorted, either in ascending or descending order.

Python Challenge #2: Convert Binary Numbers to Decimal

The challenge: Write a function that converts a binary number to its decimal equivalent.

Here's the code solution:

def binary_to_decimal(binary):
    decimal, i = 0, 0
    while(binary != 0):
        dec = binary % 10
        decimal = decimal + dec * pow(2, i)
        binary = binary//10
        i += 1
    return decimal

Code explanation:

In the above code, we define a function binary_to_decimal that takes a binary number as a parameter. We then initialized the variables decimal and i to 0.

The variable decimal is used to store the resulting decimal value and the variable i represents the current position when processing a binary number, starting from 0.

We loop through each binary digit until all digits of the binary number become 0.

while binary != 0:

Now, we extract the least significant digit of the current binary number using the modulus operator.

dec = binary % 10

And then we convert the extracted digit to its decimal equivalent by multiplying it by 2 power raised to i.

decimal = decimal + dec * pow(2, i)

Then we remove the processed digit:

Binary = binary // 10

And increment the position i to process the next binary digit:

i += 1

Finally, we return the calculated decimal value.

Python Challenge #3: Loves Me, Loves Me Not

The challenge: Given an integer n, print a string that alternates between the phrases "Loves me" and "Loves me not" for each number from 1 to n.

The sequence should start with "Loves me" and alternate accordingly.

Here's the code solution:

def phrase_loves_me_not(n):
    phrases = []
    for i in range(1,n+1):
        if i % 2 != 0:
            phrases.append("Loves me")
        else:
            phrases.append("Loves me not")
    return ", ".join(phrases)

Code explanation:

We define a function phrase_loves_me_not that takes a single parameter n.

Then, we initialize an empty list, phrases, which stores the result for each number from 1 to n.

We iterate from 1 to n inclusive:

for i in range(1, n+1):

We then check for odd indices. If the number is odd, we append “Loves me” to the list ‘phrases’.

if i % 2 != 0:
    phrases.append("Loves me")

For even indices, we append “Loves me not” in the list ‘phrases’.

else:
    phrases.append("Loves me not")

We then use the join method to concatenate all the elements in the ‘phrases’ list into a single string and return that string.

Finally we return the resulting string.

return ", ".join(phrases)

Python Challenge #4: The Tribonacci Sequence Challenge

The "Tribonacci sequence" challenge is a twist on the famous Fibonacci sequence, where each number is the sum of the preceding three numbers.

For example, 0, 1, 1, 2, 4, 7 …

The challenge: Write a function that returns the nth number in the Tribonacci sequence.

Here's the code solution:

def find_nth_tribonacci(n):
    # Base cases for n = 0, 1, 2
    if n == 0:
        return 0
    elif n == 1 or n == 2:
        return 1
    # Initialize the first three terms of the Tribonacci sequence
    a, b, c = 0, 1, 1
    for i in range(3, n + 1):
        next_term = a + b + c
        a, b, c = b, c, next_term
    return c

Code explanation:

First, we define a function named find_nth_tribonacci which takes a number n as a parameter.

We then define base cases as:

• If n is 0, the function returns 0.
• If n is 1 or 2, the function returns 1.

Note: These conditions handle the starting values of the Tribonacci sequence.

We then initialize the first three values of the Tribonacci sequence, from n = 0 to n = 2.

a, b, c = 0, 1, 1

Then, we iterate from 3 to the number n, where we calculate the next term by summing the three preceding terms (a, b, and c). We also update the values of a, b, and c to the next set of three terms in the sequence.

for i in range(3, n + 1):
    next_term = a + b + c
    a, b, c = b, c, next_term

At the end of the loop, c holds the value of the nth term in the Tribonacci sequence, so we return c.

return c

Python Challenge #5: Hide a Credit Card Number

Write a function that takes a credit card number and transforms it into a string where all digits except the last four are replaced with asterisks.

Here's the code solution:

def mask_credit_card(card_number):
    card=str(card_number)
    return "*"*(len(card) - 4) + (card[-4:])

Code explanation:

We define a function mask_credit_card that takes card_number as a parameter.

First, we convert the number into a string.

card = str(card_number)

Then to mask the card_number, we generate a string of asterisks with a length equal to the total number of digits in the credit card minus four. This masks all digits except the last four digits.

"*"*(len(card) - 4)

Then, we use the slice operation to retrieve the last four digits of the credit card number.

card[-4:]

Finally, we return the concatenated result of the asterisk string and the last four digits of the card number.

return "*"*(len(card) - 4) + card[-4:]

Python Challenge #6: SpongeCase

SpongeCase is a style of text where letters alternately appear in lower and upper case. For example, the word in spongeCase would be sPoNgEcAsE.

The challenge: Write a function that converts the given string into spongcase.

Here's the code solution:

def to_spongecase(text):
    result = []
    i = 0
    for char in text:
        if char.isalpha():
            if i % 2 == 0:
                result.append(char.lower())
            else:
                result.append(char.upper())
            i += 1
        else:
            result.append(char)

    return "".join(result)

Code explanation:

We define a function to_spongecase that takes a string text as a parameter.

Then we initialize an empty list result, and counter i to 0.

We iterate the function over each character char in the input string and check if the current character is alphabetic.

for char in text:
    if char.isalpha():

If the character at index i (adjusted for only alphabetic characters) is even, we append the result with the character converted to lowercase.

if i % 2 == 0:
    result.append(char.lower())

If the index is odd, we append the result with the character converted to uppercase.

else:
    result.append(char.upper())

After processing an alphabetic character, the index i is incremented.

In case of non-alphabetic characters, append them to the result list as they appear, without alternating their case.

After all characters have been processed, we combine them back into a string using join .

return "".join(result)

Python Challenge #7: Caesar Encryption

Caesar Encryption (also known as the Caesar Cipher) is a simple encryption technique that works by shifting the letters in the plaintext message by a certain number of positions.

The challenge: Create a function that has two parameters – a string to be encoded and an integer representing the number of positions each letter should be shifted.

Here's the code solution:

def caesar_encryption(text, shift):
    result = ""
    for char in text:
        if char.isalpha():
            start = ord('A') if char.isupper() else ord('a')
            shifted = (ord(char) - start + shift) % 26 + start
            result += chr(shifted)
        else:
            result += char
    return result

Code explanation:

We define a function caesar_encryption that takes two parameters: a string text and an integer shift.

Then we initialize an empty string to accumulate the encoded characters.

result = ""

Next, we loop through each character in the input string text.

For alphabetic characters, we calculate the new character after applying the shift.

Then we add the non-alphabetic characters like numbers to the result unchanged.

for char in text:
    if char.isalpha():
        start = ord('A') if char.isupper() else ord('a')
    shifted = (ord(char) - start + shift) % 26 + start

So how do we calculate the new character?

We determine the ASCII value of 'A' for uppercase or 'a' for lowercase letters.

First, convert the character to its ASCII code, normalize to a 0-25 range by subtracting the start and adding the shift, and then wrap it around using modulo 26 to ensure it stays within alphabet bounds.

Finally, we add the start back to map it to the correct ASCII range.

Convert the shifted value back to a character using chr() and add to the result.

result += chr(shifted)

After all characters are processed, return the encoded string.

return result

Python Challenge #8: Is the Product Divisible by the Sum?

The challenge: Create a function that takes a list of integers and returns whether the product of those integers is divisible by their sum or not.

The function should return True if the product of all the integers in the list is divisible by their sum and False otherwise.

Here's the code solution:

def is_product_divisible_by_sum(numbers):
    if not numbers:
        return False

    product = 1
    summation = 0
    for num in numbers:
        product *= num
        summation += num

    if summation == 0:
        return False

    return product % summation == 0

Code explanation:

First, we define a function is_product_divisible_by_sum, which takes a list of integers, numbers, as a parameter.

Then, we check if the input list numbers is empty. If it is empty, return False.

if not numbers:
    return False

Else, initialize two variables: product to 1 and summation to 0.

product = 1
summation = 0

Iterate over each number in the list to calculate the total product and sum of all numbers in the list.

for num in numbers:
    product *= num
    summation += num

After calculating the sum, check if the sum is zero. Dividing by zero is undefined in mathematics and would raise an error in programming, so return False.

if summation == 0:
    return False

Finally, check if the product is divisible by the sum using the modulus operator %.

Here, if the remainder is zero, that is the product is perfectly divisible by the sum, return True. Otherwise, return False.

return product % summation == 0

Wrapping Up

These are just a few challenges that can help you build your problem-solving skills. I would suggest you try these challenges on your own.

If you want to solve more challenges, you can try out the following platforms:

• Leetcode
• Programiz PRO Community Challenges
• Exercism

They are free and help you build your logical skills with hands-on experience.

Happy Coding!

But sometimes you might need to use what is commonly referred as virtual inheritance.

In this article we will discuss when you might need to use virtual inheritance and how to implement it in C++.

What is Virtual Inheritance?

In C++, a class can inherit from multiple classes which is commonly referred as multiple inheritance. But this can cause problems sometimes, as you can have multiple instances of the base class.

To tackle this problem, C++ uses a technique which ensures only one instance of a base class is present. That technique is referred as virtual inheritance.

Example of When Virtual Inheritance is Useful

Let's look at an example and then explain what's happening:

#include <iostream>

class A {
    public:
     int x = 5;
     //some other things
};
class B : public A { // inherit from the Class A.
    public:
      int i = 6;
};
class C : public A { // inherit from the Class A.
    public:
      int i = 7;
};
class D : public B, public C { // inherit from both class B and C
    // something can go here..
};

int main(){
    D obj;
    std::cout << obj.x << std::endl;
    return 0;
}

Let's see what's going on here:

First, we have a class A which is being inherited by two classes B and C. Both of these classes are then inherited by another class D.

Inside our main function, we create a new instance (object) of the class D. We then simply tried to print the value of x to the console.

It might look legit to access the value of x here, because class D is inherited from both B and C which are ultimately inherited from the class A.

But when you try to compile the above program, you get the following error:

<source>: In function 'int main()':
<source>:21:22: error: request for member 'x' is ambiguous
   21 |     std::cout << obj.x << std::endl;
      |                      ^
<source>:5:10: note: candidates are: 'int A::x'
    5 |      int x = 5;
      |          ^
<source>:5:10: note:                 'int A::x'

The error is pretty clear: error: request for member 'x' is ambiguous. Let's now see how the request is ambiguous.

If we draw the hierarchical class structure, it should become pretty clear:

Hierarchical class structure

We can see that we have multiple instances of the class A. So the request to the variable x becomes ambiguous because the compiler doesn't know which instance we are referring to – is it through B or through C ? That's the real problem.

One Way to Solve this Problem

One way to tackle the problem is to use the scope-resolution operator (::) with which we can directly specify which instance of A we want.

int main(){
    D obj;
    std::cout << obj.B::x << std::endl;
    std::cout << obj.C::x << std::endl;
}

Using the scope-resolution operator we explicitly told the compiler which instance of A we referred to.

The main problem with this approach is that it doesn't solve our problem – because our main problem is having multiple instances of class A, and we still have that. So we need to look around for some other solutions.

And the other solution is to use virtual inheritance. Let's see how it works now.

How to Use Virtual Inheritance

To inherit virtually we simply add a keyword virtual before our base class name in the derived class declaration like this:

class B : virtual public A{
    public:
      int i = 6;
};
class C : virtual public A{
    public:
      int i = 7;
};

The addition of the virtual keyword indicates that we want to inherit from A virtually.

Inheriting virtually guarantees that there will be only one instance of the base class among the derived classes that virtually inherited it. After the changes, our hierarchical class structure becomes:

The Hierarchical structure after virtual inheritance

So now if we try to compile the following code, it will successfully compile.

#include <iostream>

class A {
    public:
     int x = 5;
};
class B : virtual public A{
    public:
      int i = 6;
};
class C : virtual public A{
    public:
      int i = 7;
};
class D : public B, public C{

};

int main(){
    D obj;
    std::cout << obj.x << std::endl;

}

So with the introduction of virtual inheritance we are able to remove the ambiguities we had earlier.

Wrapping Up

In this article you learnt about the problem you might face while inheriting a class and a way to solve it using virtual inheritance.

Happy Coding!

We will finish by actually writing our own extension (Super Fun!) which allows us to copy any code snippet to our clipboard with a click of a single button.

To continue with this article:

• You need to have a basic understanding of JavaScript.

• You need the Firefox browser (or any other browser will also work)

What is a Browser Extension?

A browser extension is something you add to your browser which enhances your browsing experience by extending the capacity of your browser.

As an example, think about an ad blocker which you might have installed on your device. This makes your browsing experience better by blocking ads when you surf the web.

How to Write Your Own Basic Browser Extension

Now let's start by writing a very basic extension.

To begin, we'll create a folder inside which we create a file named manifest.json.

What is a manifest file?

A manifest file is a must have file in any browser extension. This file contains basic data about our extension like name, version, and so on.

Now inside the manifest.json file copy the following snippet:

{
  "manifest_version":2,
  "version":"1.0",
  "name":"Test",
}

[2025 Update: Chrome currently only supports version 3 for manifest.json]

How to load the extension file

For Firefox users, follow these steps:

In the address bar, search for this:

about:debugging#/runtime/this-firefox

You will see an option to Load Temporary Add-on. Click on that option and choose the manifest.json file from the directory.

For Chrome users:

In the address bar search for this:

chrome://extensions

• Enable Developer Mode and switch into it.

• Click the Load unpacked button and select the extension directory.

Hurray! You've installed the extension successfully. But the extension doesn't do anything currently. Now let's add some functionality to our extension. To do this, we'll edit our manifest.json file like this:

{
  "manifest_version":2,
  "version":"1.0",
  "name":"Test",
  "content_scripts":[
    {
     "matches":["<all_urls>"],
     "js":["main.js"]
    }
  ]
}

In the above code, we added a content script to manifest.json. Content scripts can manipulate the Document Object Model of the web page. We can inject JS (and CSS) into a web page using a content script.

"matches" contains the list of domains and subdomains where the content script should be added and js is an array of the JS files to be loaded.

Now inside the same directory create a main.js file and add the following code:

alert("The test extension is up and running")

Now reload the extension and when you visit any URLs you will see an alert message.

Don't forget to reload the extension anytime you edit the code.

How to Customize Your Browser Extension

Now let's have some more fun with our extension.

What we are going to do now is create a web extension that changes all the images of a webpage we visit to an image we choose.

For this, just add any image to the current directory and change the main.js file to:

console.log("The extension is up and running");

var images = document.getElementsByTagName('img')

for (elt of images){
   elt.src = `${browser.runtime.getURL("pp.jpg")}`
   elt.alt = 'an alt text'
}

Let's see whats going on here:

var images = document.getElementsByTagName('img')

This line of code selects all the elements in the web page with the img tag .

Then we loop through the array images using a for loop where we change the src attribute of all the img elements to a URL with the help of the runtime.getURL function.

Here pp.jpg is the name of the image file in the current directory in my device.

We need to inform our content script about the pp.jpg file by editing the manifest.json file to:

{
  "manifest_version":2,
  "version":"1.0",
  "name":"Test",
  "content_scripts":[
   {
    "matches":["<all_urls>"],
    "js":["main.js"]
   }
  ],
  "web_accessible_resources": [
        "pp.jpg"
  ]
}

Then just reload the extension and visit any URL you like. Now you should see all the images being changed to the image which is in your current working directory.

How to add icons to your extension

Add the following code in the manifest.json file:

"icons": {
  "48": "icon-48.png",
  "96": "icon-96.png"
}

How to add a toolbar button to your extension

Now we'll add a button located in the toolbar of your browser. Users can interact with the extension using this button.

To add a toolbar button, add the following lines to the manifest.json file:

"browser_action":{
   "default_icon":{
     "19":"icon-19.png",
     "38":"icon-38.png"
   }
  }

All the image files should be present in your current directory.

Now, if we reload the extension we should see an icon for our extension in the toolbar of our browser.

How to add listening events for the toolbar button

Maybe we want to do something when a user clicks the button – let's say we want to open a new tab every time the button is clicked.

For this, we'll again add the following to the manifest.json file:

"background":{
        "scripts":["background.js"]
  },
  "permissions":[
      "tabs"
  ]

Then we'll create a new file named background.js in the current working directory and add the following lines in the file:

function openTab(){

    var newTab = browser.tabs.create({
        url:'https://twitter.com/abhilekh_gautam',
        active:true
    })
}

browser.browserAction.onClicked.addListener(openTab)

Now reload the extension!

Whenever someone clicks the button, it calls the openTab function which opens a new tab with the URL that links to my twitter profile. Also, the active key, when set to true, makes the newly created tab the current tab.

Note that you can use APIs provided by browsers in the background script. For more about APIs refer to the following article: Javacript APIs.

Now that we've learned some of the basics of browser extensions, let's create an extension that we as developers can use in our daily lives.

Final Project

Alright, now we're going to write something that will be useful for us in daily life. We'll create an extension that allows you to copy code snippets from StackOverflow with a single click. So our extension will add a Copy button to the webpage which copies the code to our clipboard.

Demo

First we'll create a new folder/directory, inside which we'll add a manifest.json file.

Add the following code to the file:

{
  "manifest_version":2,
  "version":"1.0",
  "name":"copy code",
  "content_scripts":[
    {
     "matches":["*://*.stackoverflow.com/*"],
     "js":["main.js"]
    }
  ]
}

Look at the matches inside the content script – the extension will only work for StackOverflow's domain and subdomain.

Now create another JavaScript file called main.js in the same directory and add the following lines of code:

var arr =document.getElementsByClassName("s-code-block")

for(let i = 0 ; i < arr.length ; i++){
 var btn = document.createElement("button")
 btn.classList.add("copy_code_button")
 btn.appendChild(document.createTextNode("Copy"))
 arr[i].appendChild(btn)
 //styling the button
 btn.style.position = "relative"

 if(arr[i].scrollWidth === arr[i].offsetWidth && arr[i].scrollHeight === arr[i].offsetHeight)
  btn.style.left = `${arr[i].offsetWidth - 70}px`

  else if(arr[i].scrollWidth != arr[i].offsetWidth && arr[i].scrollHeight === arr[i].offsetWidth)
   btn.style.left = `${arr[i].offsetWidth - 200}px`
 else 
   btn.style.left = `${arr[i].offsetWidth - 150}px`

 if(arr[i].scrollHeight === arr[i].offsetHeight)
   btn.style.bottom = `${arr[i].offsetHeight - 50}px`

 else
   btn.style.bottom = `${arr[i].scrollHeight - 50}px`
 //end of styling the button

   console.log("Appended")
}

First of all, I selected all the elements with the class name s-code-block – but why? This is because when I inspected StackOverflow's site I found that all the code snippets were kept in a class with that name.

And then we loop through all those elements and append a button in those elements. Finally, we just position and style the button properly (the styling's not perfect yet – this is just a start).

When we load the extension using the process we went through above and visit StackOverflow, we should see a copy button.

How to add functionality to the button

Now, when the button is clicked we want the entire snippet to be copied to our clip board. To do this, add the following line of code to the main.js file:

var button = document.querySelectorAll(".copy_code_button")
 button.forEach((elm)=>{
  elm.addEventListener('click',(e)=>{
    navigator.clipboard.writeText(elm.parentNode.childNodes[0].innerText)
    alert("Copied to Clipboard")
  })
 })

First of all, we select all the buttons we have added to the site using querySelectorAll. Then we listen for the click event whenever the button is clicked.

navigator.clipboard.writeText(elm.parentNode.childNodes[0].innerText)

The above line of code copies the code to our clipboard. Whenever a snippet is copied we alert the user with the message Copied to clipboard and we are done.

Final Words

Web Extensions can be useful in various way and I hope with the help of this article you will be able to write your own extensions.

All the code can be found in this GitHub repository. Don't forget to give a pull request anytime you come up with some good styling or a new feature like clipboard history and others.

Happy Coding!

What are Keywords in C++?

Keywords are certain reserved words which have a predefined meaning in C++. Since keywords have their own predefined meaning, they cannot be used as identifiers (for example, a function's name or a variable's name).

The function definition below is an error because friend is a keyword in c++.

void friend(){
/*.......*/
}

Let's look at some of the common keywords in C++ and how they're used.

C++ Keywords

The typedef keyword in C++

Sometime it can be tedious to declare a variable of a certain type like this:

const unsigned char

Programmers have hard time declaring such variables, and they're too long to use frequently. Can't we make it shorter or create something different? Yes we can.

Using typedef we can create synonyms:

typedef const unsigned char CON_UCHAR;

So instead of using such long base types, like this:

const unsigned char x;

We can use this:

CON_UCHAR x;

typedefs are helpful for pointer declaration, too:

typedef char *const CON_PTRCHAR; //const pointer to char

typedef const char* PTR_CONCHAR; //pointer to const char

The bool keyword in C++

bool is a type name which has two values – it is either true or false.

Every non-zero value is true, while zero is false.

if(1){
std::cout<<"Hello World"<<'\n';
}
else{
std::cout<<"Sorry World<<'\n';
}

Since all non zero values are true, every time the program runs, it outputs Hello World.

Remember that the two bool values, true and false, are also keywords.

The using keyword in C++

using namespace std;

You might have used the using keyword unknowingly. It can be used like this:

using-declaration:

namespace My_space{

class My_class{
/*Your code here*/
};
}

namespace Her_space{

using My_space:: My_class;

}

This is what a using declaration looks like. A using declaration brings every declaration with a given name to a scope.

using directive:

The most common example of a using directive is this:

using namespace std;

The above line of code makes every name from std namespace available.

The public, protected, and private keywords in C++

The keywords public, protected, and private are used as access specifiers in a class.

class Home{
private:
int members;
protected:
double tot_expenditure;
public:
void display_detail();
};

The members after the private label are only accessible through member functions. If no label is provided, then it is private by default.

The members after the public label are accessible everywhere.

The members after the protected label are similar to public members for derived class and are similar to private members for non-derived class.

The enum keyword in C++

An enumeration is a user defined type. We declare enumeration using the enum keyword.

enum days{SUN, MON, TUE, WED, THU, FRI, SAT};

Here, SUN, MON, TUE ... are called enumerators and their values are assigned increasing from 0.

By default, SUN==0, MON ==1 and so on.

However, we can initialize enumerators ourselves too.

enum{ a = 5, b = 6};

By default, enumerations are converted to integers for arithmetic operations. Since enums are user defined types, we can overload operators for them, too.

The new keyword in C++

The new keyword (also a operator) is used to create objects in free store (also referred to as heap).

int main(){

int *p = new int;

*p = 20;
//..

}

For the above line of code, the new operator allocates a memory for storing an object of integer type and returns a pointer pointing to that allocated address.

The delete keyword in C++

Memory is an important resource for us. So we should use it wisely. Unwanted memory should not be occupied. So delete (also a operator) is used to deallocate memory that was previously allocated by the new operator.

int main(){

int *p = new int;
*p =20;

delete p;
//..

}

The this keyword in C++

All the (non-static) member functions know for which object they were invoked and they can refer to it using the pointer this.

class A{
int b;
public:
//...
void display() const;
};

Consider a class which has a private member b and a member function display.

Our display function would be the following:

void A::display() const{
cout<<"b = "<<b<<'\n';
}

The same code above can be written using this like so:

void A::display() const{
cout<<"b = "<<this->b<<'\n';
}

Note that this is a pointer, so we should use the -> operator. Furthermore this here refers to the object which invoked the function.

The class keyword in C++

C++ supports object oriented programming, so we have the concept of classes. The keyword class is used to declare / define a class.

class Fb_user{
//..your code here
};

struct is also a keyword. It's a class with all the members labelled public by default.

struct Fb_user{
//...Your code here
};

The above code is shorthand for this code:

class Fb_user{
public:
//..your code here
};

To learn more about classes you can refer to my in-depth article about classes here.

The operator keyword in C++

The keyword operator is used while overloading operators. The syntax for overloading an operator is the following:

return_type operator operator's_symbol(parameters){
//...Your code here...
}

To learn more about overloading operators in c++ you can refer to my article here.

The inline keyword in C++

The keyword inline is used with functions which are expanded " in line " during every call.

A member function defined within the class definition is taken to be an inline function.

But we can use the keyword inline to inline a member function like this:

class Random(){
int a;
public:
int display const();
//...
};

inline int Random::display() const{
return a;
}

The 'inline' specification is just a request to the compiler to inline a function. The compiler may ignore that request.

The goto keyword in C++

C++ also supports the goto keyword. goto is used as a jump statement to jump in and out of a block. The restriction is that we cannot jump into an exception handler.

goto statements are useful for breaking out from a nested loop or any switch case statement.

int main(){

for(int i = 0 ; i < 5 ; i++){
  for(int j = 0 ; j < 5 ; j++{
    if(){//check for some condition
    goto here;
    }
  }
}

here:
cout<<"I am here"<<;

}

So basically we use goto to jump from one block to another.

It is a good idea to avoid using goto in general, though it can sometimes be useful.

That's It!

These are some of the most common keywords in C++. I hope you had a good time reading about this (not the this pointer :) )

Happy Coding!

You can read my other blogs here.

So how can we define operators for our classes, and how should we use such operators? I will show you how in this article.

Let's begin!

What are Operators in C++?

Operators are symbols which are used to perform operations on various operands. For example:

int x = 5;
int y = 10;

int z = x + y;

For the above example + is an operator which performs the addition operation on the two operands x and y.

What is Operator Overloading in C++?

Let's check out an example first.

int x=5;
int y= 10;

int z = x+y;//z==15

string s1="Abhi";
string s2="gautam";

string s3= s1+s3;//s3==Abhigautam

Have you ever wondered about this type of code – why is z== 15 and s3== Abhigautam? This is because operators have different meanings for different types of operands.

For an integer type, the + operator gives the sum of two numbers, and for the string type it concatinates (joins) them.

So, operator overloading is all about giving new meaning to an operator. But:

• You cannot set new meaning to an operator for a built-in type.
• You cannot create new operators.

So, basically what I mean is you cannot redefine an operator and you can't create a new operator, either.

If you wished to create new operator like ** for exponential purposes, you couldn't do it.

How does overloading work?

So operator overloading lets us define the meaning of an existing operator (note that you cannot overload some operators) for the operands of a user defined type (for example, a class is a user defined type).

Overloaded operators are just functions (but of a special type) with a special keyword operator followed by the symbol of the operator to be overloaded.

/*overloading + for class type object*/

return_type operator+(params..){}

As I already mentioned, overloaded operators are just a special type of functions. They must have a return type, and parameters are always optional (as per their requirements).

So let's overload some operators for our class now to see how it works:

class Complex{
int real,imag;
public:
Complex(int re,int im):real(re),imag(im){}
Complex(){
real = 0;
imag = 0;
}
void display() const;
//overloading operators
Complex operator+(const Complex);
Complex operator-(const Complex);
};

Here we have two functions as a member function with the syntax mentioned above. So first let's understand the syntax.

Complex operator+(const Complex);
Complex operator-(const Complex);

Both of the functions here return an object of Complex type. The operator keyword followed by the operators symbol tells us which operator is being overloaded.

We also have a display function to allow us to see the display of the object's member values. We will substituted this with the overloaded operator (<<) later in the post.

void Complex::display(){
if(imag<0)
cout<<real<<imag<<"i"<<'\n';
else
cout<<real<<'+'<<imag<<"i"<<'\n';
}

How to Overload the Binary Plus (+) Operator in C++

Let's overload the + operator now.

Complex Complex::operator+(const Complex c1){
Complex temp;
temp.real = real + c1.real;
temp.imag = imag + c1.imag;
return temp;
}

After this definition, if we do the following:

Complex c1(2,2);
Complex c2(2,2);
Complex c3 = c1+c2;
c3.display();

It should be clear that c1+c2 is equivalent to this:

c1.operator+(c2);

and

operator(c1,c2);

After the call to the member function display, the output looks like this:

4+4i

So basically we defined the meaning of the + operator for our object of type Complex.

How to Overload the Binary Minus (-) Operator in C++

Now let's overload the minus operator.

Complex Complex::operator-(const Complex c1){
Complex temp;
temp.real = real - c1.real;
temp.imag = imag - c1.imag;
return temp;
}

So this is how we overload operators in c++. Let's now discuss the number of parameters that should be passed in the function.

The number of parameters passed to the function is equal to the number of operands taken by the operator.

But in case of a (non-static) member function, the number of parameters reduces by one. This is because the (non-static) member function somehow knows the object it was invoked for.

Isn't that fun? Let's now overload more operators for our class.

bool operator!=(const Complex);
bool operator==(const Complex);

How to Overload the Not Equal To (!=) Operator in C++

So our function definition for the != operator function will be this:

bool Complex::operator!=(const Complex c1){
if(real!=c1.real || real!=c1.imag){
    return true;
}
else
return false;
}

The return type is a bool, so it returns either true or false.

How to Overload the Equal To (==) Operator in C++

Similarly for the operator ==:

bool Complex::operator==(const Complex c1){
  if(real == c1.real && imag == c1.imag){
    return true;
  }
  else
  return false;
}

How to Overload the Get From (<<) Operator in C++

So let's now overload the << operator. It will be fun!

Let's see the function declaration first:

friend ostream& operator<<(ostream&,Complex);

There are few changes from the previous functions. Let's understand it more clearly.

The function is a friend function. This means that it is not within the scope of any class and cannot be invoked by an object. Also the function returns a reference to the ostream object and it takes two arguments as parameters:

• Reference to an ostream object.
• Reference to an object of class type.
You might be wondering why a friend function? Let's talk about why we need friend functions now. If an operator function is a (non-static) member function, then the left hand side operand will be bound to the this pointer that refers to the object which is calling the function. But we don't want it to be here in the case of the << operator because the left hand side operand for the << operator should be cout. And cout is an object of ostream. So to avoid the binding with the object, we used a friend function here. We can define the << operator like this for our class. c++ ostream& operator<<(ostream& os,Complex c1){ if(c1.imag<0) os<<c1.real<<c1.imag<<"i"; else os<<c1.real<<"+"<<c1.imag<<"i"; return os; } So in this way we can overload most of the operators for our class. ## Some Operators Can't Be Overloaded in C++ We cannot overload the following operators in c++:
• :: (scope resolution operator)
• . (dot operator)
• .* (member selection through pointer)

They take a name, rather than a value, as their second operand and provide a primary means of referring to members. Allowing them to be overloaded would lead to subtleties. [Stroustroup, 1994]

Moreover the ternary operator (?:) and the named operators sizeof and typeid also cannot be overloaded.

Errors to Keep in Mind

Also remember that the following declaration is an error:

int operator+(int,int);
/*error : cannot redefine operators for built in type.*/

As mentioned earlier, Redefining an operator for built in type is an error.

One last point

You should not overload operators like && and || . This is because these operators have a particular order in which an operand is evaluated. Since overloaded operators are just function calls, we cannot guarantee the order of evaluation of the operands.

That's it!

Happy Coding!

You can read my other blogs here.

You might be wondering – what is a class and why do we need them? In this article I'll go over some basics to help you understand how classes work in C++.

How Classes Work in C++

C++ has various built in types (like bool, int, floats, and so on). Each of these types has various features (for example, the size of their memory occupancy). Operators have different meanings for each different type.

For example: The '+' operator adds ints, floats, and doubles:

int x = 5;
int y = 6;

int z= x+y;//z==11

However if we use the '+' operator with strings, it concatenates those strings.

string s1 = "abhilekh";
string s2 = "gautam";

string s3=s1+s2;//s3 will be abhilekhgautam

Here, x, y, and z represent an integer, while s1, s2, and s3 represent strings. So x, y, and z are objects of type int. Meanwhile s1, s2, and s3 are objects of type string.

Note: don't confuse this with the word 'Object'. An object is anything that occupies memory.

But what if we want to have a type that represents objects in our daily life? How could you represent a house, a car, books, animals, and so on? This is why we need Classes.

A class is a user defined type. This means that you can define your own types. You can make your own types like ints, floats, and chars. You can define operators for your types and set various properties for your own types.

Classes are really a powerful feature. Let's see how they work:

class Book{
string author_name,title;
int no_of_pages,edition_no;
//...
};

Here we have created a class named Book. The keyword class is enough for us to understand that.

A book must have an author, a title, and pages – these are the members of our class. Here, book represents an entity which has those features.

But creating our own type won't be useful until we have an object of that type. So how do we do that?

int x;//x is an object of type x.

Book y;//y is an object of type Book

The only difference here is that x is an object of a built-in type (that is, int) and y is an object of the type Book (Book is a user-defined type, defined by you).

So now let's discuss the basics of defining a class, how to create objects of that class, and ways we can use those objects.

What Are Member Functions in C++?

Functions declared in a class are member functions. They can only be invoked by the object of the class in which the function is defined.

Let's now update our Book class a little bit:

class Book{
//..
public:
void update_edition(int edition);
//..
};

Thats it – update_edition is a member function of our class book. We can define our function in two ways: inside the class, and outside the class.

Let's see how each of them works:

/*Inside class declaration*/
class Book{
//..
public:
void update_edition(int edition){
//Define your function 
edition_no = edition;
}
};

/* Outside Class declaration*/
void Book::update_edition(int edition){
//Define your function here
//..
}

So what about calling the function?

Book y;//y is an object of type Book

y.update_edition(5);

Remember that only the objects of type Book can invoke the function. A call from objects of any other type will result in a syntactical error.

A (non-static) member function always knows the object for which it was invoked and can refer to it like this:

void Book::update_edition(int edition){
this->edition_no = edition;
}

Types of Member Functions in C++

There are a number of types of member functions in C++. Let's look at each one in more detail here.

Constant Member Functions

class Book{
//..
public:
//..
int display_edition() const{
return edition_no;
}
//..
};

The const keyword indicates that this function does not change the state of the function.

Changing the state of the function from constant member function will result in an error.

int Book::book_edition() const{
edition_no = edition_no + 1;//error:cannot change value in constant function
}

Static Member Functions

If you have a member function that needs access to the members of the class but does not need to be invoked by each and every object of that class, you should declare it as static.

Such functions will be part of the class but will not be part of the object.

class Book{
//..
public:
static void my_static_func();
};

A static member can be referred to without using an object.

void Book::my_static_func(){
//define here.
}

The static keyword should not be repeated in the function declaration. Static member functions do not have access to the this pointer.

Friend Functions

Friend functions are not within the scope of a class and don't have any access to this.

class Book{
//..
public:
//..
void check();
void display();
//..
};

class E_book{
//..
public:
//..
friend void Book::check();
};

Here, the member function check of class Book is a friend of class E_book.

If we want all the member functions of a class to be the friend of another class, we can use the following syntax:

class E_book{
//...
public:
//..
friend class Book;
};

Now all the functions of class Book are now friends to class E-book.

Access Specifiers

If you have a background in C, you might remember creating your own type using the struct keyword.

struct Book{
char author_name[20];
char title[20];
int no_of_page,edition_no;
};

Book b1;//b1 is an object of type Book

Structure is a user defined type. In fact, structure is a type of class that has all its members public by default. Confused?

Do you remember the public: label we used in one of our previous code snippets above? That is what we call an access specifier.

So what's the difference between private and public access specifiers?

Members after a private label are said to be private members. This means that they can only accessed by the member function of that class. If no label is provided, it is private by default.

On the other hand, members after public label are accessible everywhere.

These specifiers are used for the purpose of data hiding, data abstraction, and data encapsulation.

Constructors

A constructor is a member function which is used to initialize an object. A constructor is run whenever an object of that class type is created.

The name of the constructor function is the same as the name of the class and it does not have any return type, either.

class Book{
//..
public:
//Constructor

Book(){  //no return type and name same as the class name

//define constructor here

}
};

There can be multiple constructor of a class because there can be multiple functions with the same name reffered as function overloading.

Destructors

The destructor releases the memory occupied by the object. It simply destroys the object. The ~ (tilde) symbol denotes a destructor.

class Book{
//..
public:
//constructor
//..
//destructor
~Book(){
//destroy object here
}
};

That's it!

By using these various class concepts in c++, you can easily create new types (your own types) which you can conveniently use as built in types.

You can read my other articles here.