What are Pointers in C Programming: Concepts, Best Practices, and Examples

 


1. Introduction

Pointers are one of the most powerful features of the C programming language. Pointers are variables that hold the memory address of another variable. In this tutorial, we'll explore the basics of pointers, why they are used, and how they work.

1.1. What are Pointers?

A pointer is a variable that stores the memory address of another variable. Pointers allow you to manipulate data indirectly, by accessing the memory address of the data, rather than the data itself.

1.2. Why use Pointers?

Pointers are used for a variety of reasons, including:

  1. Dynamic memory allocation: Pointers allow you to dynamically allocate memory at runtime, which is useful for creating data structures such as linked lists and trees.

  2. Passing arguments to functions: Pointers can be used to pass arguments to functions, which can be more efficient than passing the actual data.

  3. Accessing hardware: Pointers are often used to access hardware devices, such as graphics cards and network cards.

  4. Strings: Pointers are commonly used to manipulate strings in C.

1.3. How Pointers Work:

In C, every variable is stored in memory and has an address. A pointer is a variable that holds the memory address of another variable. Pointers are declared using the * operator and can be initialized to the memory address of a variable using the & operator.

Here's an example of a pointer declaration:

arduino
int *ptr;

In this example, we're declaring a pointer named "ptr" that can point to an integer variable.

To assign a value to a pointer, we use the address-of operator (&). For example:

arduino
int x = 5;
int *ptr = &x;

In this example, we're initializing a pointer named "ptr" to the memory address of the integer variable "x".

To access the value of the variable that a pointer is pointing to, we use the dereference operator (*). For example:

perl
int x = 5;
int *ptr = &x;
printf("%d", *ptr);

In this example, we're printing the value of the integer variable "x" by dereferencing the pointer "ptr".


2. Declaring Pointers

A pointer is a variable that stores the memory address of another variable. To declare a pointer in C, you need to use the asterisk (*) symbol before the variable name. For example:

arduino
int *ptr;

This declares a pointer named ptr that can store the memory address of an integer variable.

2.1. Initializing Pointers

When you declare a pointer, it does not point to a valid memory location yet. You need to initialize the pointer to point to a valid memory location before you can use it.

To initialize a pointer, you can use the address-of operator (&) to get the memory address of a variable, and then assign that memory address to the pointer. For example:

arduino
int num = 5;
int *ptr = #

This initializes the pointer ptr to point to the memory address of the integer variable num.

You can also initialize a pointer to NULL, which means that it does not point to any memory location. For example:

arduino
int *ptr = NULL;

2.2. Pointer Syntax

The syntax for using pointers in C involves the use of the asterisk (*) symbol to dereference the pointer and access the value stored in the memory location that the pointer points to.

For example, to assign a value to the memory location that ptr points to, you would use the following syntax:

*ptr = 10;

This assigns the value 10 to the memory location that ptr points to.

To access the value stored in the memory location that ptr points to, you would also use the asterisk (*) symbol. For example:

arduino
int num = *ptr;

This assigns the value stored in the memory location that ptr points to (which is 10 in this case) to the integer variable num.

2.3. Dereferencing Pointers

Dereferencing a pointer means accessing the value stored in the memory location that the pointer points to. To dereference a pointer in C, you need to use the asterisk (*) symbol.

For example, to assign the value 10 to the memory location that ptr points to, you would use the following syntax:

*ptr = 10;

This assigns the value 10 to the memory location that ptr points to.

To access the value stored in the memory location that ptr points to, you would also use the asterisk (*) symbol. For example:

arduino
int num = *ptr;

This assigns the value stored in the memory location that ptr points to (which is 10 in this case) to the integer variable num.


3. Pointer Arithmetic in C

In C programming, a pointer is a variable that stores a memory address. Pointers are used to manipulate data indirectly by referencing memory locations rather than the values stored in them. Pointer arithmetic refers to performing arithmetic operations on pointers, such as addition, subtraction, increment, and decrement.

3.1. Understanding Pointer Arithmetic

Pointer arithmetic in C is performed on the address values stored in the pointer variable. The arithmetic operations are used to access elements of arrays, traverse data structures, and allocate memory dynamically.

When an integer is added to a pointer variable, the pointer is incremented by the size of the data type that it points to. Similarly, subtracting an integer from a pointer decrements it by the size of the data type. For example, if a pointer points to an integer array, adding 1 to the pointer will increment it to point to the next integer in the array.

Pointer arithmetic is useful for accessing elements of arrays and structures. When an array is declared, the memory for the entire array is allocated as a contiguous block of memory. Each element in the array occupies a fixed amount of memory, which is determined by the data type of the array. The elements of the array can be accessed using pointer arithmetic.

3.2. Incrementing and Decrementing Pointers:

Pointer arithmetic allows us to increment or decrement pointers by a certain number of bytes. This is useful when we want to move the pointer to a specific location in memory. We can increment or decrement the pointer using the ++ and -- operators respectively.

Example of Pointer Arithmetic in C

Let's take an example to demonstrate pointer arithmetic in C.

arduino
#include <stdio.h>

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int *p = arr; // pointer to the first element of the array
    printf("The value of arr[0] is %d\n", *p); // prints 1
    p++; // increment the pointer
    printf("The value of arr[1] is %d\n", *p); // prints 2
    return 0;
}

In the above code, we have declared an integer array arr and initialized it with values 1 to 5. We then declared a pointer variable p and initialized it to point to the first element of the array. We have printed the value of the first element of the array using the dereference operator *p. We have then incremented the pointer p to point to the second element of the array and printed its value using *p.

3.3. Pointer Arithmetic with Structures

Pointer arithmetic is also useful when working with structures. In C, a structure is a user-defined data type that can contain multiple variables of different types. When a structure variable is declared, the memory for all the variables in the structure is allocated as a contiguous block of memory.

To access the individual variables in the structure, a pointer to the structure can be used. The arrow operator -> is used to access the variables in the structure using the pointer. Pointer arithmetic can also be used to access elements of arrays inside the structure.

Example of Pointer Arithmetic with Structures in C

Let's take an example to demonstrate pointer arithmetic with structures in C.

arduino
#include <stdio.h>

struct Student {
    char name[50];
    int age;
    float grade;
};

int main() {
    struct Student s1 = {"John", 20, 3.5};
    struct Student *ptr = &s1;
    
    printf("Name: %s\n", ptr->name);
    printf("Age: %d\n", ptr->age);
    printf("Grade: %.2f\n", ptr->grade);
    
    ptr++;
    
    printf("Name: %s\n", ptr->name);
    printf("Age: %d\n", ptr->age);
    printf("Grade: %.2f\n", ptr->grade);
    
    return 0;
}

In this example, we define a structure called Student that contains three members: name, age, and grade. We then declare an instance of this structure called s1, and initialize its members using the dot operator.

We also declare a pointer to a Student structure called ptr, and assign it the address of s1 using the address-of operator &.

We then use the arrow operator -> to access the members of the structure through the pointer ptr, and print them using printf().

Next, we increment the pointer ptr by one using the increment operator ++. This has the effect of advancing the pointer to the next structure of type Student in memory.

Finally, we use printf() to print the members of the second structure pointed to by ptr.

The output of this program is:

makefile
Name: John 
Age: 20 
Grade: 3.50 
Name: (garbage) 
Age: 0 
Grade: 0.00

As you can see, the first structure is printed correctly, but the second structure contains garbage values. This is because we have advanced the pointer ptr beyond the bounds of the structure s1, and are now pointing to memory that may contain any value.

It is important to note that pointer arithmetic can be dangerous if not used carefully. You must ensure that you do not access memory beyond the bounds of the object being pointed to, or else you risk introducing errors and causing crashes in your program.


3.4. Pointer Arithmetic with Arrays:

Pointer arithmetic can also be used to access elements of an array. We can use pointer arithmetic to move the pointer to different elements of the array.

For example, let's consider the following code:

perl
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr;

printf("%d\n", *(ptr+2));

In the above code, we have an integer array arr with 5 elements. We declare a pointer variable ptr and initialize it to the address of the first element of the array arr. We then use the pointer variable ptr to access the third element of the array using pointer arithmetic. We do this by adding 2 to the pointer variable ptr using the ptr+2 notation.


3.5. Pointer Arithmetic with Strings:

Pointer arithmetic is also commonly used with strings in C. Since strings are represented as character arrays in C, we can use pointer arithmetic to manipulate strings.

For example, let's consider the following code:

arduino
char str[] = "Hello, World!";
char *ptr = str;

while(*ptr != '\0'){
    printf("%c", *ptr);
    ptr++;
}

In the above code, we have a character array str containing the string "Hello, World!". We declare a pointer variable ptr and initialize it to the address of the first character of the string str. We then use a while loop to print the characters of the string using the pointer variable. Inside the loop, we use the ptr++ operator to move the pointer to the next character of the string.


4. Pointers and Functions

Pointers can be used to pass data between functions, as well as to return data from functions. In this tutorial, we'll explore how to use pointers with functions in C.

4.1. Passing Pointers to Functions

When you pass a pointer to a function, you're passing the address of a variable, rather than the value of the variable itself. This means that any changes made to the variable inside the function will affect the original variable.

To pass a pointer to a function, you simply declare the parameter as a pointer. Here's an example:

arduino
#include <stdio.h>

void addOne(int *x) {
    (*x)++;
}

int main() {
    int num = 0;
    addOne(&num);
    printf("num is now %d\n", num);
    return 0;
}

In the above code, we define a function called addOne that takes a pointer to an integer as its parameter. Inside the function, we use the * operator to dereference the pointer and increment the value of the variable it points to.

In main(), we declare an integer variable called num and pass its address to addOne() using the & operator. After calling addOne(), we print the value of num to confirm that its value has been incremented.

4.2. Returning Pointers from Functions

You can also use pointers to return data from a function. To do this, you declare the return type of the function as a pointer. Here's an example:

arduino
#include <stdio.h>
#include <stdlib.h>

int *createArray(int size) {
    int *arr = malloc(size * sizeof(int));
    for (int i = 0; i < size; i++) {
        arr[i] = i;
    }
    return arr;
}

int main() {
    int *arr = createArray(5);
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    free(arr);
    return 0;
}

In this code, we define a function called createArray that takes an integer parameter called size and returns a pointer to an integer. Inside the function, we use the malloc() function to allocate memory for an array of integers, initialize the values of the array, and then return a pointer to the first element of the array.

In main(), we call createArray() with a size of 5 and assign the return value to a pointer variable called arr. We then use a for loop to print the values of the array, and finally free the memory allocated by createArray() using the free() function.

4.3. Example of Pointers and Functions

Let's look at a more complex example that combines both passing pointers to functions and returning pointers from functions:

Here is an example of using pointers with functions:

arduino
#include <stdio.h>

void swap(int *x, int *y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

int main() {
    int a = 5, b = 10;

    printf("Before swap: a = %d, b = %d\n", a, b);
    swap(&a, &b);
    printf("After swap: a = %d, b = %d\n", a, b);

    return 0;
}

In this example, we define a function swap() that takes two integer pointers as arguments. Inside the function, we use pointer arithmetic to access the values stored at the memory locations pointed to by the pointers. We swap the values of the two variables by using a temporary variable.

In the main() function, we declare two integer variables a and b and initialize them to 5 and 10, respectively. We then print out their values before calling the swap() function. After calling the function, we print out their values again to verify that they have been swapped.

Note that when passing pointers to a function, we use the & operator to get the address of the variable. In the swap() function, we use the * operator to dereference the pointers and access the values stored at the memory locations they point to.

Another example of using pointers with functions is to return a pointer from a function. Here is an example:

arduino
#include <stdio.h>
#include <stdlib.h>

int *create_array(int size) {
    int *arr = malloc(size * sizeof(int));
    for (int i = 0; i < size; i++) {
        arr[i] = i * 2;
    }
    return arr;
}

int main() {
    int size = 5;
    int *arr = create_array(size);
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    free(arr);
    return 0;
}

In this example, we define a function create_array() that takes an integer argument size and returns a pointer to an integer array. Inside the function, we allocate memory for the array using the malloc() function and initialize its elements to i * 2. We then return a pointer to the first element of the array.

In the main() function, we call the create_array() function with a size of 5 and assign the returned pointer to the arr variable. We then loop through the elements of the array and print them out. Finally, we free the memory allocated for the array using the free() function.

Note that when returning a pointer from a function, we must use dynamic memory allocation to allocate memory for the array. We can then return a pointer to the first element of the array. It is important to remember to free the memory allocated for the array when we are done using it to avoid memory leaks.


5. Pointer Scope and Lifetime

Local and Global Pointers: Pointers, like any other variables, can have either local or global scope. A local pointer is declared inside a function, while a global pointer is declared outside of any function. A local pointer is only visible within the function in which it is declared, while a global pointer is visible throughout the entire program.

Here is an example of a local pointer:

csharp
void function() {
  int *ptr;
  /* do something with ptr */
}

In this example, ptr is a local pointer that is only visible within the function() function. If we were to try to access ptr from outside of the function, we would get a compilation error.

Here is an example of a global pointer:

csharp
int *ptr;

int main() {
  /* do something with ptr */
}

void function() {
  /* do something with ptr */
}

In this example, ptr is a global pointer that is visible throughout the entire program. We can access ptr from anywhere within the program, including the main() function and the function() function.

5.1. Pointer Lifetime:

The lifetime of a pointer is the period of time during which the pointer is valid and can be used to access memory. The lifetime of a pointer depends on how it is created.

Local pointers have a lifetime that is tied to the scope in which they are declared. When the function in which the pointer is declared exits, the memory that the pointer points to is no longer valid, and any attempt to access that memory will result in undefined behavior.

Global pointers, on the other hand, have a lifetime that is tied to the lifetime of the program. They remain valid for the entire duration of the program and can be used to access memory from anywhere within the program.


6. Pointers and Dynamic Memory Allocation:

Dynamic memory allocation is a powerful feature of C programming language that allows programs to allocate memory at runtime. This is in contrast to static memory allocation, where the size of the memory block is fixed at compile time. Dynamic memory allocation is especially useful when the size of the memory required by a program is not known beforehand.

In C, dynamic memory allocation is achieved using two functions: malloc() and free(). In this tutorial, we will learn how to use these functions to allocate and deallocate memory dynamically.

6.1. The malloc() Function:

The malloc() function is used to allocate memory dynamically. It takes a single argument, which is the number of bytes to be allocated, and returns a pointer to the first byte of the allocated memory block.

Here is the syntax for malloc():

arduino
void* malloc(size_t size);

The argument size is of type size_t, which is an unsigned integer type defined in the stdlib.h header file. The size argument specifies the number of bytes to be allocated.

The malloc() function returns a void pointer (void*) to the first byte of the allocated memory block. This pointer can be cast to any other pointer type. If the allocation fails, malloc() returns a null pointer.

6.2. The free() Function:

The free() function is used to deallocate memory that has been allocated dynamically using malloc(). It takes a single argument, which is a pointer to the memory block to be deallocated.

Here is the syntax for free():

arduino
void free(void* ptr);

The argument ptr is a pointer to the memory block to be deallocated. After the memory has been deallocated, the pointer should no longer be used.

Example of Dynamic Memory Allocation with Pointers:

c
#include <stdio.h>
#include <stdlib.h>

int main()
{
   int *ptr, i , n;

   printf("Enter the number of elements: ");
   scanf("%d", &n);

   ptr = (int*) malloc(n * sizeof(int));

   if(ptr == NULL)                     
   {
      printf("Error! memory not allocated.");
      exit(0);
   }

   printf("Enter elements of array: ");
   for(i = 0; i < n; ++i)
   {
      scanf("%d", ptr + i);
   }

   printf("Elements of array are: ");
   for(i = 0; i < n; ++i)
   {
      printf("%d ", *(ptr + i));
   }

   free(ptr);
   return 0;
}

In this example, we have used malloc() to allocate memory dynamically for an integer array of size n. If the allocation fails, the program will terminate. We then use a for loop to read n integers from the user and store them in the dynamically allocated memory block. Finally, we use another for loop to print the elements of the array and free the memory using free().


7. Pointer Best Practices in C

Pointers are a powerful and essential feature of the C programming language. However, using them incorrectly can lead to bugs and security vulnerabilities. In this tutorial, we will cover some best practices for working with pointers in C.

7.1. Initializing Pointers:

It is always a good practice to initialize pointers when they are declared. An uninitialized pointer contains a garbage value that can lead to unpredictable behavior and hard-to-debug errors. To initialize a pointer, you can set it to NULL or assign it the address of an existing variable.

For example:

arduino
int *p = NULL; // Initializing with NULL
int x = 10;
int *q = &x;   // Initializing with the address of an existing variable

7.2. Checking for NULL Pointers:

Before dereferencing a pointer, it is a good practice to check if it is NULL. Dereferencing a NULL pointer can lead to a runtime error that can crash the program. To check if a pointer is NULL, you can use the comparison operator ==.

For example:

arduino
int *p = NULL;
if (p == NULL) {
    printf("Error: p is a null pointer\n");
}

7.3. Avoiding Pointer Arithmetic Mistakes:

Pointer arithmetic can be a powerful tool, but it is easy to make mistakes that can lead to buffer overflows, memory leaks, and other security vulnerabilities. To avoid pointer arithmetic mistakes, you can use pointer arithmetic only with arrays and structures, and always make sure that the pointer is within the bounds of the array or structure.

For example:

less
int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;  // Points to the first element of arr
int *q = p + 2;  // Points to the third element of arr

Conclusion:

In conclusion, pointers are an important concept in the C programming language. They provide the ability to manipulate memory directly, which can be very powerful but also comes with added responsibility. We learned about the basics of pointers, how to declare and initialize them, and how they can be used to manipulate memory directly.

Recap of Pointer Concepts:

  • Pointers are variables that store memory addresses.
  • Pointers can be used to manipulate memory directly.
  • Pointer arithmetic can be used to move pointers around in memory.
  • Pointers can be passed to and returned from functions.
  • Dynamic memory allocation can be used with pointers to allocate memory at runtime.

Advantages of Pointers in C Programming:

  • Pointers allow for more efficient memory usage.
  • Pointers allow for more flexibility in data structures.
  • Pointers allow for direct manipulation of memory, which can be very powerful.

Future Learning Resources:

  • The C Programming Language by Brian W. Kernighan and Dennis M. Ritchie.
  • Pointers in C by Yashavant Kanetkar.
  • C Pointers and Dynamic Memory Management by Ted Jensen.

Author
Vaneesh Behl
Passionately writing and working in Tech Space for more than a decade.

Comments

Post a Comment

Popular posts from this blog

17 Best Demo Websites for Automation Testing Practice

Image
We need demo websites for various purposes, like learning new tools and for automation testing practice. In this post, we cherry-picked some of the best websites to practice Selenium automation testing. This set of demo websites would help you to enhance your automation skills.  This post can help various people like,  Automation Testing learners, Experienced professionals, and even Automation Testing tutors/teachers. They all can benefit from these demo websites. Table of Contents 1. Techlistic Automation Practice Form 2. Amazon like Demo E-Commerce Website 3. Make My Trip like Travel Portal 4. Demo Automation Practice Web Table 5. Google.com 6. Demo Website for Handling Alerts 7. Way2Automation Demo 8. NewTours DemoAUT 9. The Demo Site 10. DemoQA 11. Para Bank 12. Orange HRM 13. Sauce Labs Demo E-Commerce Site 14. Demo Bank Demo Websites for API Automation Testing Practice 15. Restful Booker 16. Pet Store 17. Demo REST API Best Demo Websites for Automation Practice Let's take
Read more

Mastering Selenium WebDriver: 25+ Essential Commands for Effective Web Testing

Image
In this tutorial, you will learn about the most important Selenium WebDriver Commands which would be the backbone of your GUI automation scripts.  We have divided the commands in to different categories so that you can learn Selenium commands without difficulty. This Selenium Commands tutorial has explained you all the commands with Code examples and sample Selenium programs for better understanding. Table of Content 1. Selenium Browser Commands 2. Get Commands 3. Navigation Commands 4. Web Element Commands 5. Select Dropdown Commands 1. Selenium Browser Commands Browser commands are the starting point of your Selenium WebDriver script. These commands used to launch browser, maximize it, open URL to be tested and other navigation commands. i. Set Path of browser/driver executable: It is the starting point of the WebDriver script.  You have to download the browser executable file for the browser and make sure it is compatible with the version of your browser. For example, for fir
Read more

Top 7 Web Development Trends in the Market

Image
  Technology continues to advance as humans discover new methods to innovate, doing tasks quicker and more creatively than before. Developers are continuously on the lookout for new technologies that will help them move forward towards a better future.  The contemporary industry is constantly evolving, and new online technologies emerge daily. Entrepreneurs that want to interact with more consumers and stay ahead in this competitive industry may take advantage of these new trends. There aren't many industries that have as much innovation as bespoke web development. Hire WordPress developer to help entrepreneurs interact with more consumers and stay ahead. Websites, without a question, play an important part in today's commercial environment. A WordPress design agency will build you a website that functions as a separate brand, organization, and individual. Doing business on a worldwide scale has become conceivable and attainable as firms and enterprises have transcended all bou
Read more

Mastering Selenium Practice: Automating Web Tables with Demo Examples

Image
Demo Webtable 1 (Static Table) This table has 7 rows and 3 columns. So, the distribution of rows and columns is even. We can assume this table is a static or linear table. This table is easy to automate.  Company Contact Country Google Maria Anders Germany Meta Francisco Chang Mexico Microsoft Roland Mendel Austria Island Trading Helen Bennett UK Adobe Yoshi Tannamuri Canada Amazon Giovanni Rovelli Italy Demo Webtable 2 (Dynamic Table) This table has an uneven distribution of rows and columns the last row has two columns only, but the other rows have 7 columns each. So, let's assume it is a dynamic table. This table is a tougher task. Structure Country City Height Built Rank … Total 4 buildings Burj Khalifa UAE Dubai 829m 2010 1 Clock Tower Hotel Saudi Arabia Mecca 601m 2012 2 Taipei 101 Taiwan Taipei 509m 2004 3 Financial Center China Shanghai 492m 2008 4 Selenium Practice Exercises for Demo Table 2 -  Verify that there are only 4 structure values present in the table with Seleniu
Read more

Automation Practice: Automate Amazon like E-Commerce Website with Selenium

Image
In this post, you will learn to automate different functionalities of an e-commerce website. To automate this practice assignment,  you should have sound knowledge of all the Selenium concepts. We'll create a test plan and then automate an e-commerce website that is quite similar to amazon.com. Automate Amazon-like e-Comm website with Selenium for Automation Practice Table of Content 1. What should you know before starting this Project assignment? 2. Which functionalities will we automate in this Project assignment? 3. Create Test Plan for Amazon like e-commerce website 4. Automate Amazon like e-commerce website: Automate User Registration and Login of e-commerce website Automate Search feature of e-commerce website Automate "Buy Product" feature of e-Commerce website 1. What should you know before automating this automation assignment? You should know the following topics, before starting this project assignment: Software Testing Concept
Read more

Automate GoDaddy.com Features with Selenium WebDriver

Image
This post contains two assignments that helps you to learn Selenium browser commands. These are the simplest assignments. So, this assignment post is the best suited to start your automation tester journey. 1. Automate Browser Actions on GoDaddy.com If you are a beginner in automation testing and looking forward to writing your first Selenium code, then this post is the best destination for you. This assignment will teach you the basic commands of Selenium Webdriver to perform basic actions like., Launch the browser, maximize the browser window, validate the page title, and close the browser. In this post, you will find very basic step-by-step assignments which will upgrade your understanding of Selenium Webdriver and its commands. 1. Test Case - Open Godaddy.com and maximize the browser window. Steps to Automate:
Read more

What Is Artificial Intelligence (AI) and How Does It Work?

Image
Artificial Intelligence, often abbreviated as AI, is a transformative field of computer science that aims to create machines, software, or systems capable of performing tasks that typically require human intelligence. These tasks include problem-solving, learning from experience, understanding natural language, recognizing patterns, and making decisions. In this article, we will explore what AI is, its subfields, and provide examples of AI applications that have already started to shape our world. Understanding Artificial Intelligence AI is a multidisciplinary field that draws inspiration from various areas, including computer science, mathematics, psychology, neuroscience, and linguistics. At its core, AI seeks to replicate or simulate human intelligence in machines, enabling them to perform tasks autonomously, adapt to changing environments, and improve over time. Subfields of Artificial Intelligence AI encompasses several subfields, each with its unique focus and applications: 1. Ma
Read more

Top 10 Highly Paid Indian CEOs in the USA

Image
Top Indian CEOs in the USA Indian Americans have been making significant contributions to the US economy for decades. Many Indian-origin executives have reached the pinnacle of success in American corporations and hold some of the highest-paid positions in the country. In this post, we will take a look at the top 10 highly paid Indian-origin CEOs in the USA, their history, academics, salary, and net worth. 1. Sunder Pichai   Salary US$ 199.7 million Sundar Pichai is the CEO of Google and Alphabet Inc. Born in Tamil Nadu, India, Pichai grew up in a middle-class family and earned a Bachelor’s degree in Metallurgical Engineering from the Indian Institute of Technology in Kharagpur. He went on to earn a Master’s degree in Material Sciences and Engineering from Stanford University and an MBA from the Wharton School of the University of Pennsylvania. Pichai joined Google in 2004 and rose through the ranks to become CEO in 2015. His annual salary in 2021 was $2 million, and his net wort
Read more

How to Automate Google Search with Selenium WebDriver

Image
In this post, you will learn to automate Google Search using Selenium Webdriver with Java. This is a real-time example of Explicit wait command. Google search is an Ajax call. We will handle this Ajax call using the Explicit wait command of Selenium Webdriver. We can also say that we'll automate the auto-suggestion feature of search in this post. 1. What is Ajax search? Ajax stands for Asynchronous JavaScript and XML. Ajax is a new technology for creating faster and more interactive web applications. What Ajax does is: Update a web page without reloading/refreshing it Read data from the server after the page is loaded When you write something into a Search Box say "app" and it shows you similar search options that are Ajax. And you can automate that auto-suggestion box with the help of Explicit command in Selenium WebDriver . Google search is the best example of Ajax. In the case of Google search, you simply type any keyword in the search bar and just below the s
Read more

What is Java Class and Object?

Image
In this Java Class and Object tutorial, we will learn about the fundamentals of Java Programming. Java Class and Object are the base of Java. And we have tried to explain it in a simpler way. For your better understanding, we have also provided example Java programs for concepts of Java Classes and Object and Java Constructors. Classes and Objects are the fundamental building blocks of OOPS (Object Oriented Programming). A Java object is a physical and logical entity whereas a Java class is a logical entity. Table of Content 1. What is a Java Class? Syntax of java Class Explanation of example code Types Of Java Classes 2. What is a Java Object? How to create Java Object? Example Code and it's explanation What is the use of Java Objects? 3. Write your first Java Program - "Hello World" 4. What is Java Constructor? Non-Parameterized Constructor (Default) Parameterized Constructor 1. What is a Java Class? Before creating an object in Java, you need to define a class. A class
Read more