Pointer Array C

10 Key excerpts on "Pointer Array C"

• 

  eBook - ePub

  Learn C Programming from Scratch

  A step-by-step methodology with problem solving approach (English Edition)

  • Mohammad Saleem Mir(Author)
  • 2024(Publication Date)
  • BPB Publications

    (Publisher)

  It is important to mention that using pointers comes with some drawbacks, like dangling pointers, memory leaks, and accessing erroneous memory locations. To ensure proper utilization and prevent any problems, diligent management is necessary. In the C programming language, pointers are a potent tool. Direct memory manipulation, dynamic memory allocation, effective array manipulation, and other sophisticated programming methods are made possible by them. For C programming to be mastered and programs to be developed that are effective, reliable, and memory-optimized, pointers must be understood. To maintain safe and dependable code, however, adequate management and comprehension of pointers are required since with tremendous power comes great responsibility.

  Array of pointers We can declare an array of pointers just like we do in the case of an integer array or a float array like: int * ptr [5]; Example: //Array of pointers #include <stdio.h> int main () { int a =10, b = 20, c = 30; int * ptr [3]; ptr [0] = &a; //ptr [0] stores address of a … and so on ptr [1] = &b; ptr [2] = &c; printf("Values of a, b and c are %d\t%d\t%d", *ptr [0], *ptr[1], *ptr[2]); return (0); } Program example: #include <stdio.h> #include <stdlib.h> int main () { int a [5], i, *p[5];

  printf( " Input 5 elements\n");

  for (i =0; i<5; i++) { scanf("%d", &a[i]); p[i] = & a[i]; } printf("5 elements entered are\n"); for (i =0; i<5; i++) //print array elements using pointer array printf("%d", *p[i]); return (0); } We can also use an array of pointers to characters to store a list of strings as: //Array of pointers - example 3 #include <stdio.h> int main () { char *n [] = { "Zain", "Zaid", "Usman", "Imad", }; int i = 0; for (i = 0; i < 4; i++) { printf("Good Boy [%d] = %s\n", i+1, n[i]); } return (0); } Output: Good Boy [1] = Zain Good Boy [2] = Zaid Good Boy [3] = Usman Good Boy [4] = Imad Conclusion

  In conclusion, this chapter has covered crucial concepts related to arrays, string manipulation, and matrices in programming. We have explored the fundamentals of one-dimensional arrays, including accessing and modifying array elements. Additionally, we have delved into string manipulation techniques, equipping you with the skills to handle strings effectively. Furthermore, we have examined matrices and learned how to pass a two-dimensional matrix to a function. By mastering these topics, you have gained valuable knowledge to enhance your ability to work with data structures in various programming scenarios.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Learn Programming with C

  An Easy Step-by-Step Self-Practice Book for Learning C

  • Sazzad M.S. Imran, Md Atiqur Rahman Ahad(Authors)
  • 2024(Publication Date)
  • Chapman and Hall/CRC

    (Publisher)

  CHAPTER 3 Arrays and Pointers

  DOI: 10.1201/9781003302629-3

  IN C, AN ARRAY is used to hold multiple values of the same data type. The array could be one-dimensional, two-dimensional, or three-dimensional. On the other hand, pointer variables are used to hold addresses rather than values of variables. In terms of memory access, arrays and pointers are synonymous. The first element of an array is referred to by its name, whereas the value of a pointer points to any memory location.

  3.1 ARRAYS

  An array is a collection of data types that are all of the same kind. A single array variable can store, access, and handle a large amount of data. In the following C code, for example, int num[100];

  num is an integer type array with a total of 100 elements. Starting at 0 and continuing until n-1, each array element can be retrieved using appropriate indexing. The 4th, 5th, and 6th elements of the above num array, for example, are accessed with num[3], num[4], and num[5].

  We initialize the array in the same way that we would for any other data type variable.

  1. While declaration of the array: int num[4] = {5, 10, 9, 19}; or, int num[] = {5, 10, 9, 19};
  2. After declaration of the array: int num[4]; num[4] = {5, 10, 9, 19}; or, num[] = {5, 10, 9, 19};
  3. Interactively by the user after running the program. In that case, we usually use any of the C loops to access each element of the array. Example: int i, num[4]; for (i=0; i<4; i++) scanf(“%d”, &num[i]);

  When any array is declared, the array is organized such that all the array elements occupy contiguous space in memory. If the size of the integer data type is 4 bytes, then the memory organization of the array num[4] is as follows:

  3.2 2D ARRAYS

  A two-dimensional array is an array of arrays. It is also known as a matrix in C and is defined as a set of rows and columns. The following expression represents an integer type 2D array of matrix 2 × 4.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  C++ Programming

  • Yuan Dong, Fang Yang, Li Zheng(Authors)
  • 2019(Publication Date)
  • De Gruyter

    (Publisher)

  6Arrays, Pointers, and Strings

  After studying the concepts and applications of basic control structures, functions, and classes of C++, many problems can be described and solved. However, for large scales of data, especially when they are mutually correlated or are similar and correlated data, how to present and organize them efficiently remains a problem. The array type in C++ provides an effective way to organize objects of the same type.

  An important characteristic, which C++ inherits from C, is that we can directly use an address to access memory, and the pointer variable is an important data type for realizing this feature. Using pointers, we can conveniently process large amounts of data continuously stored in memory, achieve massive data sharing between functions at a comparatively low cost, and easily realize dynamic memory allocations.

  Using character arrays to make up the deficiency of string variables is an effective method inherited from C. However, from the object-oriented and security perspectives, strings represented by character arrays have deficiencies. Therefore, the standard class library of C++ provides the string class, which is a good example of expanding data types based on the class library.

  In this chapter, we will introduce the array type, pointer type, dynamic memory allocation, and how to store and process string data.

  6.1Arrays

  To understand the function of an array, please consider this problem: how does one store and process a series of n integers in a program? If n is small, for example, n is 3, we can easily declare three variables of the int type. If n is 10,000, then we need to declare 10,000 variables of int type to represent these 10,000 numbers by int

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  ANSI C Programming

  Learn ANSI C step by step

  • Yashavant Kanetkar(Author)
  • 2020(Publication Date)
  • BPB Publications

    (Publisher)

  10 Arrays

  • What are Arrays A Simple Program Using Array
  • More on Arrays Array Initialisation Bounds Checking Passing Array Elements to a Function
  • Pointers and Arrays Passing an Entire Array to a Function The Real Thing
  • Two Dimensional Arrays Initialising a 2-Dimensional Array Memory Map of a 2-Dimensional Array Pointers and 2-Dimensional Arrays Pointer to an Array Passing 2-D Array to a Function
  • Array of Pointers
  • Three-Dimensional Array
  • Summary
  • Exercise

   

  T he C language provides a capability that enables the user to design a set of similar data types, called array. This chapter describes how arrays can be created and manipulated in C.

  We should note that, in many C books and courses, arrays and pointers are taught separately. I feel it is worthwhile to deal with these topics together. This is because pointers and arrays are so closely related that discussing arrays without discussing pointers would make the discussion incomplete and wanting. In fact, all arrays make use of pointers internally. Hence, it is all too relevant to study them together rather than as isolated topics.

  What are Arrays

  For understanding the arrays properly, let us consider the following program: #include <stdio.h> int main() {   int x;   x = 5;   x = 10;   printf ("x = %d\n", x);   return 0; }

  No doubt, this program will print the value of x as 10. Why so? Because, when a value 10 is assigned to x , the earlier value of x , i.e. 5, is lost. Thus, ordinary variables (the ones which we have used so far) are capable of holding only one value at a time (as in this example). However, there are situations in which we would want to store more than one value at a time in a single variable.

  For example, suppose we wish to arrange the percentage marks obtained by 100 students in ascending order. In such a case, we have two options to store these marks in memory: (a) Construct 100 variables to store percentage marks obtained by 100 different students, i.e. each variable containing one student’s marks.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  C Programming Pocket Primer

  • Oswald Campesato(Author)
  • 2019(Publication Date)
  • Mercury Learning and Information

    (Publisher)

  5

  WORKING WITH POINTERS IN C

  T his chapter introduces pointers, which are often misunderstood and can be intimidating because of the conflicting and inaccurate explanation that you can find on the Internet.

  Languages like Java have removed pointers entirely because of their complexity, and C requires that a block of code be marked unsafe in order to access pointers. On the other hand, pointers are used extensively in C, so a good foundation is required in order to become an effective C programmer.

  The first part of this chapter introduces you to the concept of a pointer in C, along with examples of pointers to numbers, arrays, and strings. This section also contains C programs that use pointers to split a string and for loops that use pointers to find the divisors of a number.

  The second part of this chapter defines pointers to arrays of numbers as well as pointers to functions. You will learn how to use pointers to reverse a string, find uppercase and lowercase letters, how to remove whitespaces from a string, and how to count words in a line of text. The final section of this chapter contains C programs that illustrate how to define pointers to functions, function pointers as arguments, and how to define pointers to pointers.

  Now let’s start with a brief introduction about pointers and pointer declarations, as well as the address of a variable, dereferencing pointers, and using pointer arithmetic. As you will see, pointer-based arithmetic emulates array indexing and the two views of an array as an indexed data structure or as a buffer with pointer arithmetic are crucial to the development and understanding of why C pointers work in the ways that they do.

  WHAT ARE POINTERS?

   

  A variable declared with a “pointer” data type contains a memory address indicating where the actual data is located. With pointer data types it is common to say that the pointer variable “points to” the actual data rather than talking about a memory address. Here are some examples of data that a pointer “points to:”

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Learn C Programming

  • Jeff Szuhay(Author)
  • 2022(Publication Date)
  • Packt Publishing

    (Publisher)

  Chapter 14 : Understanding Arrays and Pointers

  C pointers and arrays are closely related; so closely, in fact, that they are often interchangeable! However, this does not mean pointers and arrays are identical. We will explore this relationship and why we might want to use either array notation or pointer notation to access array elements. Most often, we will need to understand this relationship when we pass arrays to functions. So, understanding the interchangeability of arrays and pointers will be essential to making any function that manipulates arrays more flexible and expressive.

  Having read two previous chapters, Chapter 11 , Working with Arrays , and Chapter 13 , Using Pointers , is essential to understanding the concepts presented here. Please do not skip those chapters before reading this one.

  The following topics will be covered in this chapter:

  • Reviewing the memory layout of arrays
  • Understanding the relationship between array names and pointers
  • Using pointers in various ways to access and traverse arrays
  • Expanding the use of pointer arithmetic, specifically for array elements
  • Creating an array of pointers to arrays and a two-dimensional (2D ) array to highlight their differences

  Technical requirements

  Continue to use the tools you chose from the Technical requirements  section of Chapter 1 , Running Hello, World! .

  The source code for this chapter can be found at https://github.com/PacktPublishing/Learn-C-Programming-Second-Edition/tree/main/Chapter14 .

  Understanding array names and pointers

  As we have seen, elements of arrays can always be accessed via indices and traversed by means of an integer offset from the zeroth element. Sometimes, however, it is more convenient to access array elements via a pointer equivalent.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Introduction to Windows® and Graphics Programming with Visual C++®

  (with Companion Media Pack)

  • Roger Mayne(Author)
  • 2015(Publication Date)
  • WSPC

    (Publisher)

  In reality, like all variables of type float, the entries in Vector[5] each occupy four bytes in memory (where a “byte” contains eight “bits”, i.e. ones and zeros) with two bytes used for the number itself and two bytes used for its mantissa. One special feature of using pointers to specify addresses in memory is that incrementing a pointer will automatically move within memory from one variable in an array to the next. It is not necessary to worry about the byte-to-byte details. This is true regardless of the variable type (integer, float, double, etc.) as well for structures and objects which will be discussed shortly. This is also the reason why pointers are always declared in association with a particular type of variable, structure or object.

  Figure 2.3 “Pointing” to Locations in Memory for Entries in the Array Vector[5]

  2.2.3Using a pointer with a one-dimensional array

  In Section 2.1 we worked with a simple one-dimensional array and in Section 2.2.2 we discussed the “pointer” concept for addressing the entries in an array. In this section we will bring the two ideas together in a simple program and use a pointer to allow a function to have direct access to an array. The program below is from the example project VecPointer that you can find in the folder Chap2\3_VecPointer. Double clicking on VecPointer.sln will make the file VecPointer.cpp available to you. The listing of the file is shown in Table 2.3 . The VecPointer example performs the same operations as the VectorG example of Section 2.1 . However, in this case, the array Vector is not declared globally. Instead, it is declared locally in main() and passed to the function now called PtVecFunction by use of a pointer to the array.

  In looking through the listing of VecPointer.cpp in Table 2.3 , we see that the floating point array Vector[5] is only declared locally in main() at line 08. Line 09 declares the floating point pointer PtVector. In line 10 the pointer PtVector is set to the address of the first entry in the array. In summary, after lines 08-10, the pointer PtVector contains the address of the array entry Vector[0].

  The function PtVecFunction is initially declared at line 04 and is shown in prototype form in lines 25-35. It has been prepared to manipulate the one-dimensional array by having access to it through a pointer. The input argument “float*” shown for PtVecFunction in line 04 means that a floating point pointer is expected as an input to PtVecFunction. In the redeclaration of PtVecFunction in line 25, the pointer is given the variable name Ptr for use within the function. The for loop of lines 30–34 then manipulates the contents of the array Vector[5] in line 32 using Ptr. It addresses each entry using the expression *(Ptr + i) and adds two to its contents. In this expression, the “*” should be read as “contents of” according to the discussion of Section 2.2.1

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  C Programming

  Learn to Code

  • Sisir Kumar Jena(Author)
  • 2021(Publication Date)
  • Chapman and Hall/CRC

    (Publisher)

  11 Pointers

  DOI: 10.1201/9781003188254-11

  11.1 Introduction

  A pointer is something that indicates or points. From the layman’s point of view a pointer is a long-tapered stick for indicating objects, as on a chart or a blackboard (Figure 11.1 ). Sometimes we use a laser pointer to point or show an object displayed on a screen (Figure 11.1). So, we can say a pointer is indirectly pointing to a device of our concerns.

  Figure 11.1 Pointing device.

  To understand the way in which pointers operate, it is first necessary to understand the concept of indirection. You are familiar with this concept from your everyday life. For example, suppose you need to buy a new computer for your department. In the company that you work for, all purchases are handled by the purchasing department. So, you call Mr. X in purchasing and ask him to order the new computer for you. Mr. X, in turn, calls the local supply store to order the computer. This approach to obtain your new computer is actually an indirect one because you are not ordering the computer directly from the supply store yourself.

  This same notion of indirection applies to the way pointers work in C. A pointer provides an indirect means of accessing the value of a particular data item. In C programming, a pointer is a variable that represents the location (rather than the value) of a data item, such as a variable or an array element. Pointers play an important role in the development process. A pointer has a number of useful applications. For example, pointers can be used to pass information back and forth between a function and its reference point. In particular, pointers provide a way to return multiple data items from a function via function arguments.

  11.2 Basic Knowledge

  Within the computer’s memory, every stored data item occupies one or more contiguous memory cells (i.e., adjacent words or bytes). The number of memory cells required to store a data item depends on the type of data item. For example, a single character will typically be stored in one byte (eight bits) of memory; an integer usually requires four contiguous bytes; a floating-point number requires four contiguous bytes; and a double-precision quantity requires eight contiguous bytes.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  C++ for Financial Mathematics

  • John Armstrong(Author)
  • 2017(Publication Date)
  • Chapman and Hall/CRC

    (Publisher)

  Arrays are only of interest if you know the size of your arrays when your code is compiled. For example, when working with 3D computer graphics, arrays of length 3 can be useful.

  Tip: Don’t use arrays Vectors do everything you want to do with arrays and much more.

  11.2   Pointers

  11.2.1   new and delete

  Because arrays are not flexible enough, the C language also contains the concept of a pointer. This allows a C programmer to work with sequences of data of varying lengths.

      int n = 5;    int * myArray = new int [n];    for (int i=0; i<n; i++) {        cout <<" Entry " <<i<<"=";        cout << myArray [i];        cout << "\n";    }    delete [] myArray ;

  The code above uses the new ...[] operator to allocate a chunk of memory. In this case we are creating a sequence of int data types in memory, but you could use other data types instead.

  The good news is that you can choose the size of the chunk of memory at run time. Unlike with an array, you don’t have to choose the size in advance when you write your program.

  The downside of using new [] is that the memory will not be automatically deleted when the variable goes out of scope (see Section 4.7 for the meaning of the word scope). You must use delete [] to free the memory created with the new[] operator. This is good and bad. With arrays we couldn’t return arrays because the memory was deleted automatically, but on the other hand we didn’t have to remember to call delete[] . With memory created using new[] we have to remember to delete the memory by hand, but you can safely return the data.

  The value returned by new int[n] is called a pointer . It has type int* which means “a pointer to an int ”. In actual fact the array discussed in the previous section was of type int* too. It’s just that the notation for arrays in C hides the fact that an array-valued variable is just a pointer to a memory location. All that the int* myArray contains is the memory address where the array starts. As a result, we have to remember ourselves that the block of memory is of length n

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Ivor Horton's Beginning Visual C++ 2008

  • Ivor Horton(Author)
  • 2011(Publication Date)
  • Wrox

    (Publisher)

  Of course, all this applies to pointers to any type. A pointer to type char is used here purely for illustrative purposes. Pointers and Arrays

  Array names can behave like pointers under some circumstances. In most situations, if you use the name of a one-dimensional array by itself, it is automatically converted to a pointer to the first element of the array. Note that this is not the case when the array name is used as the operand of the sizeof operator.

  If you have these declarations,

  double* pdata; double data[5];

  you can write this assignment:

  pdata = data; // Initialize pointer with the array address

  This is assigning the address of the first element of the array data to the pointer pdata . Using the array name by itself refers to the address of the array. If you use the array name data with an index value, it refers to the contents of the element corresponding to that index value. So, if you want to store the address of that element in the pointer, you have to use the address-of operator:

  pdata = &data[1];

  Here, the pointer pdata contains the address of the second element of the array.

  Pointer Arithmetic

  You can perform arithmetic operations with pointers. You are limited to addition and subtraction in terms of arithmetic, but you can also perform comparisons of pointer values to produce a logical result. Arithmetic with a pointer implicitly assumes that the pointer points to an array, and that the arithmetic operation is on the address contained in the pointer. For the pointer pdata for example, you could assign the address of the third element of the array data to a pointer with this statement:

  pdata = &data[2];

  In this case, the expression pdata+1 would refer to the address of data[3] , the fourth element of the data array, so you could make the pointer point to this element by writing this statement:

  pdata += 1; // Increment pdata to the next element

  This statement increments the address contained in pdata by the number of bytes occupied by one element of the array data . In general, the expression pdata+n , where n can be any expression resulting in an integer, adds n*sizeof(double) to the address contained in the pointer pdata because it was declared to be of type pointer to double . This is illustrated in Figure 4-8

  Sign up to read

  Learn more about book