What are the ramifications of simply checking a pointers value in a conditional statement?

Question

Here goes my code:

#include <iostream>
using namespace std;
int countX(char*, char);

int main() {
    char msg[] = "there are four a's in this sentence a a";
    //char *ptr = msg; // <----- question 2!
    cout << countX(msg, 'a');
    cin.get();
}

int countX(char* ptr, char x) {
    int c = 0;
    for (; *ptr; ptr++) {
        if (*ptr == x) c++;
    }
    /*
    while(*ptr) {
        if(*ptr==x) c++;
        ptr++;
    }
    */
    return c;
}

I was wondering a few things specifically regarding safe practice and pointers:

1. My conditional statement in the for-loop ; *ptr ;, is this safe practice? Will it every break if there happens to be something stored in the memory address right next to the last element in the array? Is that even possible? How does it know when to terminate? When is *ptr deemed unacceptable?
2. (concerning the commented out char *ptr = msg; in the main): I understand a pointer and an array are very similar, however, is there a difference between passing the actual array to countX vs. passing a pointer (which points to the beginning of the array?).
3. In countX I've provided two different ways to approach the simple problem. Is one considered superior over the other?

Answer 1

Q My conditional statement in the for-loop ; *ptr ;, is this safe practice?

A Yes, most of the time. See below for more details.

Q Will it every (I know you meant ever) break if there happens to be something stored in the memory address right next to the last element in the array?

A Yes.

Q Is that even possible?

A Yes. You can easily access the memory one past the last character of the array and make it something other than the null character.

Q How does it know when to terminate?

A It will terminate when you encounter the terminating null character of a string. If the null character has been replaced by something else, the behavior is going to be unpredictable.

Q When is *ptr deemed unacceptable?

A If the string length is len, it is OK to set ptr in the range msg and msg+len. If ptr points to anything beyond that range, the behavior is undefined. Hence, they should be considered unacceptable in a program.

Q (concerning the commented out char *ptr = msg; in the main): I understand a pointer and an array are very similar, however, is there a difference between passing the actual array to countX vs. passing a pointer (which points to the beginning of the array?).

A No. They are identical.

Q In countX I've provided two different ways to approach the simple problem. Is one considered superior over the other?

A No they are not. It comes down to personal taste. I happen to like to use for loops while I know people that like to use while loops.

Answer 2

Q1 : My conditional statement in the for-loop ; *ptr ;, is this safe practice? Will it every break if there happens to be something stored in the memory address right next to the last element in the array? Is that even possible? How does it know when to terminate? When is *ptr deemed unacceptable?

Ans : When used with c-style strings, yes it is a safe practice. Any c-style string necessarily ends with '\0', which is basically 0. The behavior is undefined when the '\0' is not there. So the loop would break at the end of the string. *ptr would never terminate if it is anything other than a c-style string. For example, a c-style "hello" is actually an array containing 'h', 'e', 'l', 'l', 'o', '\0'. So, the loop exists at '\0', never accessing the memory after it. it is possible to access the memory after the last element of an array. For example,

int a[5] = {0,1,2,3,4,5};
int *p = a+5;

p is accessing the element after the last element of the array a.

Q2 :(concerning the commented out char *ptr = msg; in the main): I understand a pointer and an array are very similar, however, is there a difference between passing the actual array to countX vs. passing a pointer (which points to the beginning of the array?).

Ans : Arrays and pointers are not exactly similar. Its just that an array name is nothing but a constant pointer pointing to the first element of the array. Consider the previous example i wrote. In that, a[3], 3[a], *(a+3) and *(p+3), all refer to the same element. Since you are passing by value, the value of the constant pointer msg would just be copied to ptr. So, no, it would make no difference.

Q3 : In countX I've provided two different ways to approach the simple problem. Is one considered superior over the other?

Ans : I am not an expert, but i'd say no.

Also, you probably dont need the cin.get().

Answer 3

This is very bad practice.

What you're doing in the for condition is basically if (*ptr), in other words, does the memory pointed to by ptr contain a non-zero value?

So if the memory location after the string contains a non-zero value (maybe from another variable using the space) or a garbage value then your loop could go infinite, or give you an incorrect value. Instead you should run the loop from 0 to the length of your string.