Arrays (Part - 2), C Programming Interview Questions Quant Notes | EduRev

Placement Papers - Technical & HR Questions

Created by: Prateek Kaushik

Quant : Arrays (Part - 2), C Programming Interview Questions Quant Notes | EduRev

The document Arrays (Part - 2), C Programming Interview Questions Quant Notes | EduRev is a part of the Quant Course Placement Papers - Technical & HR Questions.
All you need of Quant at this link: Quant

5. Can you assign a different address to an array tag?

No, although in one common special case, it looks as if you can. An array tag is not something you can put on the left side of an assignment operator. (It's not an "lvalue," let alone a "modifiable lvalue.") An array is an object; the array tag is a pointer to the first element in that object.

For an external or static array, the array tag is a constant value known at link time. You can no more change the value of such an array tag than you can change the value of 7.

Assigning to an array tag would be missing the point. An array tag is not a pointer. A pointer says, "Here's one element; there might be others before or after it." An array tag says, "Here's the first element of an array; there's nothing before it, and you should use an index to find anything after it." If you want a pointer, use a pointer.

In one special case, it looks as if you can change an array tag:

 

void  f( char a[ 12 ] )
{
        ++a;    /* legal! */
}

 

The trick here is that array parameters aren't really arrays. They're really pointers. The preceding example is equivalent to this:

 

void  f( char *a )
{
        ++a;    /* certainly legal */
}

 

You can write this function so that the array tag can't be modified. Oddly enough, you need to use pointer syntax:

 

void  f( char * const a )
{
        ++a;    /* illegal */
}

 

Here, the parameter is an lvalue, but the const keyword means it's not modifiable.


6. What is the difference between array_name and &array_name?

One is a pointer to the first element in the array; the other is a pointer to the array as a whole.

An array is a type. It has a base type (what it's an array of ), a size (unless it's an "incomplete" array), and a value (the value of the whole array). You can get a pointer to this value:

 

char a[ MAX ];      /* array of MAX characters */
char *p;            /* pointer to one character */
/* pa is declared below */
pa = & a;
p = a;  /* = & a[ 0 ] */

 

After running that code fragment, you might find that p and pa would be printed as the same value; they both point to the same address. They point to different types of MAX characters.

The wrong answer is

char *( ap[ MAX ] );

which is the same as this:

char *ap[ MAX ];

This code reads, "ap is an array of MAX pointers to characters."

 

7. Why can't constant values be used to define an array's initial size?

There are times when constant values can be used and there are times when they can't. A C program can use what C considers to be constant expressions, but not everything C++ would accept.

When defining the size of an array, you need to use a constant expression. A constant expression will always have the same value, no matter what happens at runtime, and it's easy for the compiler to figure out what that value is. It might be a simple numeric literal:

char a[ 512 ];

Or it might be a "manifest constant" defined by the preprocessor:

 

#define MAX     512
/* ... */
char    a[ MAX ];

 

Or it might be a sizeof:

char a[ sizeof( struct cacheObject ) ];

Or it might be an expression built up of constant expressions:

char buf[ sizeof( struct cacheObject ) * MAX ];

Enumerations are allowed too.

An initialized const int variable is not a constant expression in C:

int max = 512; /* not a constant expression in C */

char buffer[ max ]; /* not valid C */

Using const ints as array sizes is perfectly legal in C++; it's even recommended. That puts a burden on C++ compilers (to keep track of the values of const int variables) that C compilers don't need to worry about. On the other hand, it frees C++ programs from using the C preprocessor quite so much.


8. What is the difference between a string and an array?

An array is an array of anything. A string is a specific kind of an array with a well-known convention to determine its length.

There are two kinds of programming languages: those in which a string is just an array of characters, and those in which it's a special type. In C, a string is just an array of characters (type char), with one wrinkle: a C string always ends with a NUL character. The "value" of an array is the same as the address of (or a pointer to) the first element; so, frequently, a C string and a pointer to char are used to mean the same thing.

An array can be any length. If it's passed to a function, there's no way the function can tell how long the array is supposed to be, unless some convention is used. The convention for strings is NUL termination; the last character is an ASCII NUL ('\0') character.

In C, you can have a literal for an integer, such as the value of 42; for a character, such as the value of '*'; or for a floating-point number, such as the value of 4.2e1 for a float or double.

There's no such thing as a literal for an array of integers, or an arbitrary array of characters. It would be very hard to write a program without string literals, though, so C provides them. Remember, C strings conventionally end with a NUL character, so C string literals do as well. "six times nine" is 15 characters long (including the NULterminator), not just the 14 characters you can see.

There's a little-known, but very useful, rule about string literals. If you have two or more string literals, one after the other, the compiler treats them as if they were one big string literal. There's only one terminating NULcharacter. That means that "Hello, " "world" is the same as "Hello, world", and that

 

char    message[] =
  "This is an extremely long prompt\n"
  "How long is it?\n"
  "It's so long,\n"
  "It wouldn't fit on one line\n";

 

When defining a string variable, you need to have either an array that's long enough or a pointer to some area that's long enough. Make sure that you leave room for the NUL terminator. The following example code has a problem:

 

char greeting[ 12 ];
strcpy( greeting, "Hello, world" );    /* trouble */

 

There's a problem because greeting has room for only 12 characters, and "Hello, world" is 13 characters long (including the terminating NUL character). The NUL character will be copied to someplace beyond the greeting array, probably trashing something else nearby in memory. On the other hand,

char greeting[ 12 ] = "Hello, world"; /* not a string */

is OK if you treat greeting as a char array, not a string. Because there wasn't room for the NUL terminator, the NUL is not part of greeting. A better way to do this is to write

char greeting[] = "Hello, world";

to make the compiler figure out how much room is needed for everything, including the terminating NULcharacter.

String literals are arrays of characters (type char), not arrays of constant characters (type const char). The ANSI C committee could have redefined them to be arrays of const char, but millions of lines of code would have screamed in terror and suddenly not compiled. The compiler won't stop you from trying to modify the contents of a string literal. You shouldn't do it, though. A compiler can choose to put string literals in some part of memory that can't be modified擁n ROM, or somewhere the memory mapping registers will forbid writes. Even if string literals are someplace where they could be modified, the compiler can make them shared.

For example, if you write

 

char    *p = "message";
char    *q = "message";
p[ 4 ] = '\0';  /* p now points to "mess" */

 

(and the literals are modifiable), the compiler can take one of two actions. It can create two separate string constants, or it can create just one (that both p and q point to). Depending on what the compiler did, q might still be a message, or it might just be a mess.

Offer running on EduRev: Apply code STAYHOME200 to get INR 200 off on our premium plan EduRev Infinity!

Dynamic Test

Content Category

Related Searches

past year papers

,

shortcuts and tricks

,

Exam

,

Viva Questions

,

practice quizzes

,

C Programming Interview Questions Quant Notes | EduRev

,

MCQs

,

C Programming Interview Questions Quant Notes | EduRev

,

Sample Paper

,

Arrays (Part - 2)

,

C Programming Interview Questions Quant Notes | EduRev

,

Extra Questions

,

Arrays (Part - 2)

,

Previous Year Questions with Solutions

,

Arrays (Part - 2)

,

pdf

,

mock tests for examination

,

ppt

,

video lectures

,

Free

,

Objective type Questions

,

Semester Notes

,

Summary

,

Important questions

,

study material

;