Code Questions Answers 1. Using structure, write a C program to print the date of joining of a person.

Transcription

1 Code Questions Answers 1. Using structure, write a C program to print the date of joining of a person. To print the date of joining of a person #include<conio.h> #include<stdio.h> struct personal char name[30]; int day; int month; int year; float salary; ; void main() struct personal p; printf( Enter the name:\n)"; gets(p.name); printf( Enter the day of joining:\n)"; scanf( %d,&p.day); printf( Enter the month of joining:\n"); scanf( %d,&p.month); printf( Enter the year of joining:\n)"; scanf( %d,&p.year); printf( Enter the salary:\n)"; scanf( %f, & p.salary); printf( \nname:",p.name); printf("\ndate of joining:%d %d %d",p.day,p.month,p.year); printf( Salary:",p.salary); getch(); 2. Explain the different functions used for handling errors duing I/O operations with proper syntax. clearer: void clearerr(file *stream); clearerr clears the error and EOF indicators for the stream. feof: int feof(file *stream); feof returns non-zero if the stream's EOF indicator is set, zero otherwise. ferror: int ferror(file *stream); ferror returns non-zero if the stream's error indicator is set, zero otherwise. perror: void perror(const char *s); 3. Explain with example, the two general classes of situations where conditional compilation is useful. perror prints a single-line error message on the program's standard output, prefixed by the string pointed to by s, with a colon and a space appended. The error message is determined by the value of errno and is intended to give some explanation of the condition causing the error. Conditional compilation is useful in two general classes of situations: Class 1: You are trying to write a portable program, but the way you do something is different depending on what compiler, operating system, or computer you're using. For example, in ANSI C, the function to delete a file is remove. On older Unix systems, however, the function was called unlink. So if filename is a variable containing the name of a file you want to delete, and if you want to be able to compile the program under these older Unix systems, you might write #ifdef unix unlink(filename); #else remove(filename); #endif Then, you could place the line #define unix at the top of the file when compiling under an old Unix system. (Since all you're using the macro unix for is to control the #ifdef, you don't need to give it any replacement text at all. Any definition for a macro, even if the replacement text is empty, causes an #ifdef to succeed.) 4D15 MC0061 Page 1 of 5

2 (In fact, in this example, you wouldn't even need to define the macro unix at all, because C compilers on old Unix systems tend to predefine it for you, precisely so you can make tests like these.) Class 2: You want to compile several different versions of your program, with different features present in the different versions. (One common example is whether you turn debugging statements on or off. You can bracket each debugging printout with #ifdef DEBUG and #endif, and then turn on debugging only when you need it.) For example, you might use lines like this: #ifdef DEBUG printf("x is %d\n", x); #endif to print out the value of the variable x at some point in your program to see if it's what you expect. To enable debugging printouts, you insert the line #define DEBUG at the top of the file, and to turn them off, you delete that line, but the debugging printouts quietly remain in your code, temporarily deactivated, but ready to reactivate if you find yourself needing them again later. (Also, instead of inserting and deleting the #define line, you might use a compiler flag such as -DDEBUG to define the macro DEBUG from the compiler invocating line.) 4. Explain the steps for converting an infix expression to prefix form. 5. Explain how the memory is allocated in malloc and calloc? 1. In an infix expression, a binary operator separates its operands (a unary operator precedes its operand). In a postfix expression, the operands of an operator precede the operator. In a prefix expression, the operator precedes its operands. Like postfix, a prefix expression is parenthesis-free, that is, any infix expression can be unambiguously written in its prefix equivalent without the need for parentheses. 2. To convert an infix expression to reverse-prefix, it is scanned from right to left. A queue of operands is maintained noting that the order of operands in infix and prefix remains the same. Thus, while scanning the infix expression, whenever an operand is encountered, it is pushed in a queue. If the scanned element is a right parenthesis ( ) ), it is pushed in a stack of operators. If the scanned element is a left parenthesis ( ( ), the queue of operands is emptied to the prefix output, followed by the popping of all the operators up to, but excluding, a right parenthesis in the operator stack. 3. If the scanned element is an arbitrary operator o, then the stack of operators is checked for operators with a greater priority than o. Such operators are popped and written to the prefix output after emptying the operand queue. The operator o is finally pushed to the stack. 4. When the scanning of the infix expression is complete, first the operand queue, and then the operator stack, are emptied to the prefix output. Any whitespace in the infix input is ignored. Thus the prefix output can be reversed to get the required prefix expression of the infix input. (2.5*4=10 Marks) 101 numbers? We have an array of 100 chars which we pass to getline to receive the user's input, what if the user types a line of 200 characters? If we're lucky, the relevant parts of the program check how much of an array they've used, and print an error message or otherwise gracefully abort before overflowing the array. If we're not so lucky, a program may sail off the end of an array, overwriting other data and behaving quite badly. In either case, the user doesn't get his job done. How can we avoid the restrictions of fixed-size arrays? The answers all involve the standard library function malloc. Very simply, malloc returns a pointer to n bytes of memory which we can do anything we want to with. If we didn't want to read a line of input into a fixed-size array, we could use malloc, instead. It takes the following form: ptr=(cast-type *)malloc(byte-size) where ptr is a pointer of type cast-type. The malloc returns a pointer(of cast-type) to an area of memory with size byte-size. Here is an example #include <stdlib.h> char *line; int linelen = 100; line = (char *)malloc(linelen); 4D15 MC0061 Page 2 of 5

3 getline(line, linelen); malloc is declared in <stdlib.h>, so we #include that header in any program that calls malloc. A ``byte'' in C is, by definition, an amount of storage suitable for storing one character, so the above invocation of malloc gives us exactly as many chars as we ask for. We could illustrate the resulting pointer like this: The 100 bytes of memory (not all of which are shown) pointed to by line are those allocated by malloc. (They are brand-new memory, conceptually a bit different from the memory which the compiler arranges to have allocated automatically for our conventional variables. The 100 boxes in the figure don't have a name next to them, because they're not storage for a variable we've declared.) As a second example, we might have occasion to allocate a piece of memory, and to copy a string into it with strcpy: char *p = (char *)malloc(15); strcpy(p, "Hello, world!"); When copying strings, remember that all strings have a terminating \0 character. If you use strlen to count the characters in a string for you, that count will not include the trailing \0, so you must add one before calling malloc: char *somestring, *copy;... copy = (char *)malloc(strlen(somestring) + 1); /* +1 for \0 */ strcpy(copy, somestring); What if we're not allocating characters, but integers? If we want to allocate 100 ints, how many bytes is that? If we know how big ints are on our machine (i.e. depending on whether we're using a 16- or 32-bit machine) we could try to compute it ourselves, but it's much safer and more portable to let C compute it for us. C has a sizeof operator, which computes the size, in bytes, of a variable or type. It's just what we need when calling malloc. To allocate space for 100 ints, we could call int *ip =(int *)malloc(100 * sizeof(int)); The use of the sizeof operator tends to look like a function call, but it's really an operator, and it does its work at compile time. Since we can use array indexing syntax on pointers, we can treat a pointer variable after a call to malloc almost exactly as if it were an array. In particular, after the above call to malloc initializes ip to point at storage for 100 ints, we can access ip[0], ip[1],... up to ip[99]. This way, we can get the effect of an array even if we don't know until run time how big the ``array'' should be. (In a later section we'll see how we might deal with the case where we're not even sure at the point we begin using it how big an ``array'' will eventually have to be.) Our examples so far have all had a significant omission: they have not checked malloc's return value. Obviously, no real computer has an infinite amount of memory available, so there is no guarantee that malloc will be able to give us as much memory as we ask for. If we call malloc( ), or if we call malloc(10) 10,000,000 times, we're probably going to run out of memory. When malloc is unable to allocate the requested memory, it returns a null pointer. A null pointer, remember, points definitively nowhere. It's a ``not a pointer'' marker; it's not a pointer you can use. Therefore, whenever you call malloc, it's vital to check the returned pointer before using it! If you call malloc, and it returns a null pointer, and you go off and use that null pointer as if it pointed somewhere, your program probably won't last long. Instead, a program should immediately check for a null pointer, and if it receives one, it should at the very least print an error message and exit, or perhaps figure out some way of proceeding without the memory it asked for. But it cannot go on to use the null pointer it got back from malloc in any way, because that null pointer by definition points nowhere. (``It cannot use a null pointer in any way'' means that the program cannot use the * or [] operators on such a pointer value, or pass it to any function that expects a valid pointer.) A call to malloc, with an error check, typically looks something like this: int *ip = (int *)malloc(100 * sizeof(int)); if(ip == NULL) 4D15 MC0061 Page 3 of 5

4 printf("out of memory\n"); exit or return After printing the error message, this code should return to its caller, or exit from the program entirely; it cannot proceed with the code that would have used ip. Of course, in our examples so far, we've still limited ourselves to ``fixed size'' regions of memory, because we've been calling malloc with fixed arguments like 10 or 100. (Our call to getline is still limited to 100-character lines, or whatever number we set the linelen variable to; our ip variable still points at only 100 ints.) However, since the sizes are now values which can in principle be determined at run-time, we've at least moved beyond having to recompile the program (with a bigger array) to accommodate longer lines, and with a little more work, we could arrange that the ``arrays'' automatically grew to be as large as required. (For example, we could write something like getline which could read the longest input line actually seen) Allocating memory with calloc calloc is another memory allocation function that is normally used for requesting memory space at run time for storing derived data types such as arrays and structures. While malloc allocates a single block of storage space, calloc allocates multiple blocks of storage, each of the same size, and then sets all bytes to zero. The general form of calloc is: ptr=(cast-type *)calloc(n, elem-size); The above statement allocates contiguous space for n blocks, each of size elem-size bytes. All bytes are initialized to zero and a pointer to the first byte of the allocated region is returned. If there is not enough space, a NULL pointer is returned. Program 3.1 Program to illustrate the use of malloc and calloc functions #include <stdio.h> #include <malloc.h> main() int *base; int i; int cnt=0; int sum=0; printf("how many integers you have to store \n"); scanf("%d",&cnt); if(!base) printf("unable to allocate size \n"); else for(int j=0;j<cnt;j++) *(base+j)=5; sum = 0; for(int j=0;j<cnt;j++) sum = sum + *(base+j); printf("total sum is %d\n",sum); free(base); base = (int *)calloc(10,2); 6. Write the sequence of rules that are applied while The sequence of rules that are applied while evaluating expressions: All short type are automatically converted to int ; then 1. If one of the operands is long double, the other will be converted to long double 4D15 MC0061 Page 4 of 5

5 evaluating expressions. and the result will be long double; 2. else, if one of the operands is double, the other will be converted to double and the result will be double; 3. else, if one of the operands is float, the other will be converted to float and the result will be float; 4. else, if one of the operands is unsigned long int, the other will be converted to unsigned long int and the result will be unsigned long int; 5. else if one of the operands is long int and the other is unsigned int, then: if unsigned int can be converted to long int, the unsigned int operand will be converted as such and the result will be long int; else, both operands will be converted to unsigned long int and the result will be unsigned long int; 6. else, if one of the operands is long int, the other will be converted to long int and the result will be long int; 7. else, if one of the operands is unsigned int, the other will be converted to unsigned int and the result will be unsigned int; The final result of an expression is converted to type of the variable on the left of the assignment sign before assigning the value to it. However, the following changes are introduced during the final assignment: 1. float to int causes truncation of the fractional part. 2. double to float causes rounding of digits. 3. long int to int causes dropping of the excess higher order bits 4D15 MC0061 Page 5 of 5