C for Geeks

check if a number is of 2's power

2013-11-17T01:07:00.002-08:00

It is generally asked in interviews to check if a number can be converted into 2's power or not.

For e.g

8= 2^3

16=2^4

and so on...

Now if we solve this program without bit manipulation operators,

It will be difficult to solve it.

Hint:

IF a number is of 2's power, then its binary representation will have only one 1.

e.g 16= 10000

8 = 1000

and you may check for any number.

Now the problem is, how to implement this logic.

let say our number is 16,

then

binary of 16= 10000

and

binary of 15= 01111

16 & 15 = 00000

This result is only possible when number is of 2's power.

So generalized concept is

x = number & (number-1)

if(x==0)

{

printf("number is of 2's power");

}

else

{

printf("Tata bye bye.");

}

Cheers !!!!

C Preprocessor directives

2012-10-31T02:18:00.003-07:00

he C preprocessor modifies a source code file before handing it over to the compiler. You're most likely used to using the preprocessor to include files directly into other files, or #define constants, but the preprocessor can also be used to create "inlined" code using macros expanded at compile time and to prevent code from being compiled twice.

There are essentially three uses of the preprocessor--directives, constants, and macros. Directives are commands that tell the preprocessor to skip part of a file, include another file, or define a constant or macro. Directives always begin with a sharp sign (#) and for readability should be placed flush to the left of the page. All other uses of the preprocessor involve processing #define'd constants or macros. Typically, constants and macros are written in ALL CAPS to indicate they are special (as we will see).

Header Files

The #include directive tells the preprocessor to grab the text of a file and place it directly into the current file. Typically, such statements are placed at the top of a program--hence the name "header file" for files thus included.

Constants

If we write

#define [identifier name] [value]

whenever [identifier name] shows up in the file, it will be replaced by [value].

If you are defining a constant in terms of a mathematical expression, it is wise to surround the entire value in parentheses:

#define PI_PLUS_ONE (3.14 + 1)

By doing so, you avoid the possibility that an order of operations issue will destroy the meaning of your constant:

x = PI_PLUS_ONE * 5;

Without parentheses, the above would be converted to

x = 3.14 + 1 * 5;

which would result in 1 * 5 being evaluated before the addition, not after. Oops!

It is also possible to write simply

#define [identifier name]

which defines [identifier name] without giving it a value. This can be useful in conjunction with another set of directives that allow conditional compilation.

Conditional Compilation

There are a whole set of options that can be used to determine whether the preprocessor will remove lines of code before handing the file to the compiler. They include #if, #elif, #else, #ifdef, and #ifndef. An #if or #if/#elif/#else block or a #ifdef or #ifndef block must be terminated with a closing #endif.

The #if directive takes a numerical argument that evaluates to true if it's non-zero. If its argument is false, then code until the closing #else, #elif, of #endif will be excluded.

Commenting out Code

Conditional compilation is a particularly useful way to comment out a block of code that contains multi-line comments (which cannot be nested).

#if 0
/* comment ...
*/

// code

/* comment */
#endif

Include Guards

Another common problem is that a header file is required in multiple other header files that are later included into a source code file, with the result often being that variables, structs, classes or functions appear to be defined multiple times (once for each time the header file is included). This can result in a lot of compile-time headaches. Fortunately, the preprocessor provides an easy technique for ensuring that any given file is included once and only once.

By using the #ifndef directive, you can include a block of text only if a particular expression is undefined; then, within the header file, you can define the expression. This ensures that the code in the #ifndef is included only the first time the file is loaded.

#ifndef _FILE_NAME_H_
#define _FILE_NAME_H_

/* code */

#endif // #ifndef _FILE_NAME_H_

Notice that it's not necessary to actually give a value to the expression _FILE_NAME_H_. It's sufficient to include the line "#define _FILE_NAME_H_" to make it "defined". (Note that there is an n in #ifndef--it stands for "if not defined").

A similar tactic can be used for defining specific constants, such as NULL:

#ifndef NULL
#define NULL (void *)0
#endif // #ifndef NULL

Notice that it's useful to comment which conditional statement a particular #endif terminates. This is particularly true because preprocessor directives are rarely indented, so it can be hard to follow the flow of execution.

Macros

The other major use of the preprocessor is to define macros. The advantage of a macro is that it can be type-neutral (this can also be a disadvantage, of course), and it's inlined directly into the code, so there isn't any function call overhead. (Note that in C++, it's possible to get around both of these issues with templated functions and the inline keyword.)

A macro definition is usually of the following form:

#define MACRO_NAME(arg1, arg2, ...) [code to expand to]

For instance, a simple increment macro might look like this:

#define INCREMENT(x) x++

They look a lot like function calls, but they're not so simple. There are actually a couple of tricky points when it comes to working with macros. First, remember that the exact text of the macro argument is "pasted in" to the macro. For instance, if you wrote something like this:

#define MULT(x, y) x * y

and then wrote

int z = MULT(3 + 2, 4 + 2);

what value do you expect z to end up with? The obvious answer, 30, is wrong! That's because what happens when the macro MULT expands is that it looks like this:

int z = 3 + 2 * 4 + 2;    // 2 * 4 will be evaluated first!

So z would end up with the value 13! This is almost certainly not what you want to happen. The way to avoid it is to force the arguments themselves to be evaluated before the rest of the macro body. You can do this by surrounding them by parentheses in the macro definition:

#define MULT(x, y) (x) * (y)
// now MULT(3 + 2, 4 + 2) will expand to (3 + 2) * (4 + 2)

But this isn't the only gotcha! It is also generally a good idea to surround the macro's code in parentheses if you expect it to return a value. Otherwise, you can get similar problems as when you define a constant. For instance, the following macro, which adds 5 to a given argument, has problems when embedded within a larger statement:

#define ADD_FIVE(a) (a) + 5

int x = ADD_FIVE(3) * 3;
// this expands to (3) + 5 * 3, so 5 * 3 is evaluated first
// Now x is 18, not 24!

To fix this, you generally want to surround the whole macro body with parentheses to prevent the surrounding context from affecting the macro body.

#define ADD_FIVE(a) ((a) + 5)

int x = ADD_FIVE(3) * 3;

On the other hand, if you have a multiline macro that you are using for its side effects, rather than to compute a value, you probably want to wrap it within curly braces so you don't have problems when using it following an if statement.

// We use a trick involving exclusive-or to swap two variables
#define SWAP(a, b)  a ^= b; b ^= a; a ^= b; 

int x = 10;
int y = 5;

// works OK
SWAP(x, y);

// What happens now?
if(x < 0)
    SWAP(x, y);

When SWAP is expanded in the second example, only the first statement, a ^= b, is governed by the conditional; the other two statements will always execute. What we really meant was that all of the statements should be grouped together, which we can enforce using curly braces:

#define SWAP(a, b)  {a ^= b; b ^= a; a ^= b;}

Now, there is still a bit more to our story! What if you write code like so:

#define SWAP(a, b)  { a ^= b; b ^= a; a ^= b; }

int x = 10;
int y = 5;
int z = 4;

// What happens now?
if(x < 0)
    SWAP(x, y);
else
    SWAP(x, z);

Then it will not compile because semicolon after the closing curly brace will break the flow between if and else. The solution? Use a do-while loop:

#define SWAP(a, b)  do { a ^= b; b ^= a; a ^= b; } while ( 0 )

int x = 10;
int y = 5;
int z = 4;

// What happens now?
if(x < 0)
    SWAP(x, y);
else
    SWAP(x, z);

Now the semi-colon doesn't break anything because it is part of the expression. (By the way, note that we didn't surround the arguments in parentheses because we don't expect anyone to pass an expression into swap!)

More Gotchas

By now, you've probably realized why people don't really like using macros. They're dangerous, they're picky, and they're just not that safe. Perhaps the most irritating problem with macros is that you don't want to pass arguments with "side effects" to macros. By side effects, I mean any expression that does something besides evaluate to a value. For instance, ++x evaluates to x+1, but it also increments x. This increment operation is a side effect.

The problem with side effects is that macros don't evaluate their arguments; they just paste them into the macro text when performing the substitution. So something like

#define MAX(a, b) ((a) < (b) ? (b) : (a))
int x = 5, y = 10;
int z = MAX(x++, y++);

will end up looking like this:

int x = (x++ < y++ ? y++ : x++)

The problem here is that y++ ends up being evaluated twice! The nasty consequence is that after this expression, y will have a value of 12 rather than the expected 11. This can be a real pain to debug!

Multiline macros

Until now, we've seen only short, one line macros (possibly taking advantage of the semicolon to put multiple statements on one line.) It turns out that by using a the "\" to indicate a line continuation, we can write our macros across multiple lines to make them a bit more readable.

For instance, we could rewrite swap as

#define SWAP(a, b)  {                   \
                        a ^= b;         \
                        b ^= a;         \ 
                        a ^= b;         \
                    }

Notice that you do not need a slash at the end of the last line! The slash tells the preprocessor that the macro continues to the next line, not that the line is a continuation from a previous line.

Aside from readability, writing multi-line macros may make it more obvious that you need to use curly braces to surround the body because it's more clear that multiple effects are happening at once.

Advanced Macro Tricks

In addition to simple substitution, the preprocessor can also perform a bit of extra work on macro arguments, such as turning them into strings or pasting them together.

Pasting Tokens

Each argument passed to a macro is a token, and sometimes it might be expedient to paste arguments together to form a new token. This could come in handy if you have a complicated structure and you'd like to debug your program by printing out different fields. Instead of writing out the whole structure each time, you might use a macro to pass in the field of the structure to print.

To paste tokens in a macro, use ## between the two things to paste together.

For instance

#define BUILD_FIELD(field) my_struct.inner_struct.union_a.##field

Now, when used with a particular field name, it will expand to something like

my_struct.inner_struct.union_a.field1

The tokens are literally pasted together.

String-izing Tokens

Another potentially useful macro option is to turn a token into a string containing the literal text of the token. This might be useful for printing out the token. The syntax is simple--simply prefix the token with a pound sign (#).

#define PRINT_TOKEN(token) printf(#token " is %d", token)

For instance, PRINT_TOKEN(foo) would expand to

printf("<foo>" " is %d" <foo>)

(Note that in C, string literals next to each other are concatenated, so something like "token" " is " " this " will effectively become "token is this". This can be useful for formatting printf statements.)

For instance, you might use it to print the value of an expression as well as the expression itself (for debugging purposes).

PRINT_TOKEN(x + y);

Memset(),memcpy() and memmove() functions in c

2012-10-08T21:16:00.005-07:00

The memset() Function

To set all the bytes in a block of memory to a particular value, use memset(). The function prototype is

void * memset(void *dest, int c, size_t count);

The argument dest points to the block of memory. c is the value to set, and count is the number of bytes, starting at dest, to be set. Note that while c is a type int, it is treated as a type char. In other words, only the low-order byte is used, and you can specify values of c only in the range 0 through 255.
Use memset() to initialize a block of memory to a specified value. Because this function can use only a type char as the initialization value, it is not useful for working with blocks of data types other than type char, except when you want to initialize to 0. In other words, it wouldn't be efficient to use memset() to initialize an array of type int to the value 99, but you could initialize all array elements to the value 0. memset() will be demonstrated in program below.

The memcpy() Function

memcpy() copies bytes of data between memory blocks, sometimes called buffers. This function doesn't care about the type of data being copied--it simply makes an exact byte-for-byte copy. The function prototype is

void *memcpy(void *dest, void *src, size_t count);

The arguments dest and src point to the destination and source memory blocks, respectively. count specifies the number of bytes to be copied. The return value is dest. If the two blocks of memory overlap, the function might not operate properly--some of the data in src might be overwritten before being copied. Use the memmove() function, discussed next, to handle overlapping memory blocks. memcpy() will be demonstrated in program below.

The memmove() Function

memmove() is very much like memcpy(), copying a specified number of bytes from one memory block to another. It's more flexible, however, because it can handle overlapping memory blocks properly. Because memmove() can do everything memcpy() can do with the added flexibility of dealing with overlapping blocks, you rarely, if ever, should have a reason to use memcpy(). The prototype is

void *memmove(void *dest, void *src, size_t count);

dest and src point to the destination and source memory blocks, and count specifies the number of bytes to be copied. The return value is dest. If the blocks overlap, this function ensures that the source data in the overlapped region is copied before being overwritten. Sample program below demonstrates memset(), memcpy(), and memmove().

A demonstration of memset(), memcpy(), and memmove().

1: /* Demonstrating memset(), memcpy(), and memmove(). */
2:
3: #include <stdio.h>
4: #include <string.h>
4:
5: char message1[60] = "Four score and seven years ago ...";
6: char message2[60] = "abcdefghijklmnopqrstuvwxyz";
7: char temp[60];
8:
9: main()
10: {
11:    printf("\nmessage1[] before memset():\t%s", message1);
12:    memset(message1 + 5, `@', 10);
13:    printf("\nmessage1[] after memset():\t%s", message1);
14:
15:    strcpy(temp, message2);
16:    printf("\n\nOriginal message: %s", temp);
17:    memcpy(temp + 4, temp + 16, 10);
18:    printf("\nAfter memcpy() without overlap:\t%s", temp);
19:    strcpy(temp, message2);
20:    memcpy(temp + 6, temp + 4, 10);
21:    printf("\nAfter memcpy() with overlap:\t%s", temp);
22:
23:    strcpy(temp, message2);
24:    printf("\n\nOriginal message: %s", temp);
25:    memmove(temp + 4, temp + 16, 10);
26:    printf("\nAfter memmove() without overlap:\t%s", temp);
27:    strcpy(temp, message2);
28:    memmove(temp + 6, temp + 4, 10);
29:    printf("\nAfter memmove() with overlap:\t%s\n", temp);
30:
31: }
message1[] before memset():     Four score and seven years ago ...
message1[] after memset():      Four @@@@@@@@@@seven years ago ...
Original message: abcdefghijklmnopqrstuvwxyz
After memcpy() without overlap: abcdqrstuvwxyzopqrstuvwxyz
After memcpy() with overlap:    abcdefefefefefefqrstuvwxyz
Original message: abcdefghijklmnopqrstuvwxyz
After memmove() without overlap:        abcdqrstuvwxyzopqrstuvwxyz
After memmove() with overlap:   abcdefefghijklmnqrstuvwxyz

ANALYSIS: The operation of memset() is straightforward. Note how the pointer notation message1 + 5 is used to specify that memset() is to start setting characters at the sixth character in message1[] (remember, arrays are zero-based). As a result, the 6th through 15th characters in message1[] have been changed to @.
When source and destination do not overlap, memcpy() works fine. The 10 characters of temp[] starting at position 17 (the letters q through z) have been copied to positions 5 though 14, where the letters e though n were originally located. If, however, the source and destination overlap, things are different. When the function tries to copy 10 characters starting at position 4 to position 6, an overlap of 8 positions occurs. You might expect the letters e through n to be copied over the letters g through p. Instead, the letters e and f are repeated five times.
If there's no overlap, memmove() works just like memcpy(). With overlap, however, memmove() copies the original source characters to the destination.

DO use memmove() instead of memcpy() in case you're dealing with overlapping memory regions. DON'T try to use memset() to initialize type int, float, or double arrays to any value other than 0.

Connect oracle with C/C++

2012-10-07T09:06:00.002-07:00

Interviewers often ask can you connect C/C++ with database or not?
It is tricky for those who haven't done it before.
But the answer is YES. We can connect it using a language Pro *C (or simply pro-C)
Here is the tutorial for doing it.

Overview

Embedded SQL is a method of combining the computing power of a high-level language like C/C++ and the database manipulation capabilities of SQL. It allows you to execute any SQL statement from an application program. Oracle's embedded SQL environment is called Pro*C.A Pro*C program is compiled in two steps. First, the Pro*C precompiler recognizes the SQL statements embedded in the program, and replaces them with appropriate calls to the functions in the SQL runtime library. The output is pure C/C++ code with all the pure C/C++ portions intact. Then, a regular C/C++ compiler is used to compile the code and produces the executable.

Pro*C Syntax

SQL

All SQL statements need to start with EXEC SQL and end with a semicolon ";". You can place the SQL statements anywhere within a C/C++ block, with the restriction that the declarative statements do not come after the executable statements. As an example:

    {
        int a;
        /* ... */
        EXEC SQL SELECT salary INTO :a
                 FROM Employee
                 WHERE SSN=876543210;
        /* ... */
        printf("The salary is %d\n", a);
        /* ... */
    }

Preprocessor Directives

The C/C++ preprocessor directives that work with Pro*C are #include and #if. Pro*C does not recognize #define. For example, the following code is invalid:

    #define THE_SSN 876543210
    /* ... */
    EXEC SQL SELECT salary INTO :a
             FROM Employee
             WHERE SSN = THE_SSN;    /* INVALID */

Statement Labels

You can connect C/C++ labels with SQL as in:

    EXEC SQL WHENEVER SQLERROR GOTO error_in_SQL;
    /* ... */
error_in_SQL:
    /* do error handling */

Host Variables

Basics

Host variables are the key to the communication between the host program and the database. A host variable expression must resolve to an lvalue (i.e., it can be assigned). You can declare host variables according to C syntax, as you declare regular C variables. The host variable declarations can be placed wherever C variable declarations can be placed. The C datatypes that can be used with Oracle include:

char
char[n]
int
short
long
float
double
VARCHAR[n] - This is a psuedo-type recognized by the Pro*C precompiler. It is used to represent blank-padded, variable-length strings. Pro*C precompiler will convert it into a structure with a 2-byte length field and a n-byte character array.

You cannot use register storage-class specifier for the host variables.A host variable reference must be prefixed with a colon ":" in SQL statements, but should not be prefixed with a colon in C statements. When specifying a string literal via a host variable, the single quotes must be omitted; Pro*C understands that you are specifying a string based on the declared type of the host variable. C function calls and most of the pointer arithmetic expressions cannot be used as host variable references even though they may indeed resolve to lvalues. The following code illustrates both legal and illegal host variable references:

int deptnos[3] = { 000, 111, 222 };
int get_deptno() { return deptnos[2]; }
int *get_deptnoptr() { return &(deptnos[2]); }
int main() {
    int x; char *y; int z;
    /* ... */
    EXEC SQL INSERT INTO emp(empno, ename, deptno)
        VALUES(:x, :y, :z);         /* LEGAL */
    EXEC SQL INSERT INTO emp(empno, ename, deptno)
        VALUES(:x + 1,              /* LEGAL: the reference is to x */
               'Big Shot',          /* LEGAL: but not really a host var */
               :deptnos[2]);        /* LEGAL: array element is fine */
    EXEC SQL INSERT INTO emp(empno, ename, deptno)
        VALUES(:x, :y,
               :(*(deptnos+2)));    /* ILLEGAL: although it has an
lvalue */
    EXEC SQL INSERT INTO emp(empno, ename, deptno)
        VALUES(:x, :y,
               :get_deptno());      /* ILLEGAL: no function calls */
    EXEC SQL INSERT INTO emp(empno, ename, deptno)
        VALUES(:x, :y,
               :(*get_depnoptr())); /* ILLEGAL: although it has an lvalue */
    /* ... */
}

Pointers

You can define pointers using the regular C syntax, and use them in embedded SQL statements. As usual, prefix them with a colon:

    int *x;
    /* ... */
    EXEC SQL SELECT xyz INTO :x FROM ...;

The result of this SELECT statement will be written into *x, not x.

Structures

Structures can be used as host variables, as illustrated in the following example:

    typedef struct {
        char name[21];    /* one greater than column length; for '\0' */
        int SSN;
    } Emp;
    /* ... */
    Emp bigshot;
    /* ... */
    EXEC SQL INSERT INTO emp (ename, eSSN)
        VALUES (:bigshot);

Arrays

Host arrays can be used in the following way:

    int emp_number[50];
    char name[50][11];
    /* ... */
    EXEC SQL INSERT INTO emp(emp_number, name)
        VALUES (:emp_number, :emp_name);

which will insert all the 50 tuples in one go.Arrays can only be single dimensional. The example char name[50][11] would seem to contradict that rule. However, Pro*C actually considers name a one-dimensional array of strings rather than a two-dimensional array of characters. You can also have arrays of structures.
When using arrays to store the results of a query, if the size of the host array (say n) is smaller than the actual number of tuples returned by the query, then only the first n result tuples will be entered into the host array.

Indicator Variables

Indicator variables are essentially "NULL flags" attached to host variables. You can associate every host variable with an optional indicator variable. An indicator variable must be defined as a 2-byte integer (using the typeshort) and, in SQL statements, must be prefixed by a colon and immediately follow its host variable. Or, you may use the keyword INDICATOR in between the host variable and indicator variable. Here is an example:

    short indicator_var;
    EXEC SQL SELECT xyz INTO :host_var:indicator_var
        FROM ...;
    /* ... */
    EXEC SQL INSERT INTO R
        VALUES(:host_var INDICATOR :indicator_var, ...);

You can use indicator variables in the INTO clause of a SELECT statement to detect NULL's or truncated values in the output host variables. The values Oracle can assign to an indicator variable have the following meanings:

`-1`	The column value is `NULL`, so the value of the host variable is indeterminate.
`0`	Oracle assigned an intact column value to the host variable.
`>0`	Oracle assigned a truncated column value to the host variable. The integer returned by the indicator variable is the original length of the column value.
`-2`	Oracle assigned a truncated column variable to the host variable, but the original column value could not be determined.

You can also use indicator variables in the VALUES and SET clause of an INSERT or UPDATE statement to assign NULL's to input host variables. The values your program can assign to an indicator variable have the following meanings:

`-1`	Oracle will assign a `NULL` to the column, ignoring the value of the host variable.
`>=0`	Oracle will assign the value of the host variable to the column.

Datatype Equivalencing

Oracle recognizes two kinds of datatypes: internal and external. Internal datatypes specify how Oracle stores column values in database tables. External datatypes specify the formats used to store values in input and output host variables. At precompile time, a default Oracle external datatype is assigned to each host variable. Datatype equivalencing allows you to override this default equivalencing and lets you control the way Oracle interprets the input data and formats the output data.The equivalencing can be done on a variable-by-variable basis using the VAR statement. The syntax is:

    EXEC SQL VAR <host_var> IS <type_name> [ (<length>) ];

For example, suppose you want to select employee names from the emp table, and then pass them to a routine that expects C-style '\0'-terminated strings. You need not explicitly '\0'-terminate the names yourself. Simply equivalence a host variable to the STRING external datatype, as follows:

    char emp_name[21];
    EXEC SQL VAR emp_name IS STRING(21);

The length of the ename column in the emp table is 20 characters, so you allot emp_name 21 characters to accommodate the '\0'-terminator. STRING is an Oracle external datatype specifically designed to interface with C-style strings. When you select a value from the ename column into emp_name, Oracle will automatically '\0'-terminate the value for you.You can also equivalence user-defined datatypes to Oracle external datatypes using the TYPE statement. The syntax is:

    EXEC SQL TYPE <user_type> IS <type_name> [ (<length>) ] [REFERENCE];

You can declare a user-defined type to be a pointer, either explicitly, as a pointer to a scalar or structure, or implicitly as an array, and then use this type in a TYPE statement. In these cases, you need to use the REFERENCEclause at the end of the statement, as shown below:

    typedef unsigned char *my_raw;
    EXEC SQL TYPE my_raw IS VARRAW(4000) REFERENCE;
    my_raw buffer;
    /* ... */
    buffer = malloc(4004);

Here we allocated more memory than the type length (4000) because the precompiler also returns the length, and may add padding after the length in order to meet the alignment requirement on your system.

Dynamic SQL

While embedded SQL is fine for fixed applications, sometimes it is important for a program to dynamically create entire SQL statements. With dynamic SQL, a statement stored in a string variable can be issued. PREPAREturns a character string into a SQL statement, and EXECUTE executes that statement. Consider the following example.

    char *s = "INSERT INTO emp VALUES(1234, 'jon', 3)";
    EXEC SQL PREPARE q FROM :s;
    EXEC SQL EXECUTE q;

Alternatively, PREPARE and EXECUTE may be combined into one statement:

    char *s = "INSERT INTO emp VALUES(1234, 'jon', 3)";
    EXEC SQL EXECUTE IMMEDIATE :s;

TransactionsOracle PRO*C supports transactions as defined by the SQL standard. A transaction is a sequence of SQL statements that Oracle treats as a single unit of work. A transaction begins at your first SQL statement. A transaction ends when you issue "EXEC SQL COMMIT" (to make permanent any database changes during the current transaction) or "EXEC SQL ROLLBACK" (to undo any changes since the current transaction began). After the current transaction ends with your COMMIT or ROLLBACK statement, the next executable SQL statement will automatically begin a new transaction. If your program exits without calling EXEC SQL COMMIT, all database changes will be discarded.

Error HandlingAfter each executable SQL statement, your program can find the status of execution either by explicit checking of SQLCA, or by implicit checking using the WHENEVER statement. These two ways are covered in details below.

SQLCA

SQLCA (SQL Communications Area) is used to detect errors and status changes in your program. This structure contains components that are filled in by Oracle at runtime after every executable SQL statement.To use SQLCA you need to include the header file sqlca.h using the #include directive. In case you need to include sqlca.h at many places, you need to first undefine the macro SQLCA with #undef SQLCA. The relevant chunk of sqlca.h follows:

#ifndef SQLCA
#define SQLCA 1

struct sqlca {
    /* ub1 */ char sqlcaid[8];
    /* b4 */ long sqlabc;
    /* b4 */ long sqlcode;
    struct {
        /* ub2 */ unsigned short sqlerrml;
        /* ub1 */ char sqlerrmc[70];
    } sqlerrm;
    /* ub1 */ char sqlerrp[8];
    /* b4 */ long sqlerrd[6];
    /* ub1 */ char sqlwarn[8];
    /* ub1 */ char sqlext[8];
};
/* ... */

The fields in sqlca have the following meaning:

sqlcaid This string component is initialized to "SQLCA" to identify the SQL Communications Area.

sqlcabc This integer component holds the length, in bytes, of the SQLCA structure.

sqlcode

This integer component holds the status code of the most recently executed SQL statement:

`0`	No error.
`>0`	Statement executed but exception detected. This occurs when Oracle cannot find a row that meets your `WHERE` condition or when a `SELECT INTO` or `FETCH` returns no rows.
`<0`	Oracle did not execute the statement because of an error. When such errors occur, the current transaction should, in most cases, be rolled back.

sqlerrm

This embedded structure contains the following two components:

sqlerrml - Length of the message text stored in sqlerrmc.
sqlerrmc - Up to 70 characters of the message text corresponding to the error code stored in sqlcode.

sqlerrp Reserved for future use.

sqlerrd

This array of binary integers has six elements:

sqlerrd[0] - Future use.
sqlerrd[1] - Future use.
sqlerrd[2] - Numbers of rows processed by the most recent SQL statement.
sqlerrd[3] - Future use.
sqlerrd[4] - Offset that specifies the character position at which a parse error begins in the most recent SQL statement.
sqlerrd[5] - Future use.

sqlwarn

This array of single characters has eight elements used as warning flags. Oracle sets a flag by assigning to it the character 'W'.

`sqlwarn[0]`	Set if any other flag is set.
`sqlwarn[1]`	Set if a truncated column value was assigned to an output host variable.
`sqlwarn[2]`	Set if a `NULL` column value is not used in computing a SQL aggregate such as `AVG` or `SUM`.
`sqlwarn[3]`	Set if the number of columns in `SELECT` does not equal the number of host variables specified in `INTO`.
`sqlwarn[4]`	Set if every row in a table was processed by an `UPDATE` or `DELETE` statement without a `WHERE` clause.
`sqlwarn[5]`	Set if a procedure/function/package/package body creation command fails because of a PL/SQL compilation error.
`sqlwarn[6]`	No longer in use.
`sqlwarn[7]`	No longer in use.

sqlext Reserved for future use.

SQLCA can only accommodate error messages up to 70 characters long in its sqlerrm component. To get the full text of longer (or nested) error messages, you need the sqlglm() function:

    void sqlglm(char *msg_buf, size_t *buf_size, size_t *msg_length);

where msg_buf is the character buffer in which you want Oracle to store the error message; buf_size specifies the size of msg_buf in bytes; Oracle stores the actual length of the error message in *msg_length. The maximum length of an Oracle error message is 512 bytes.

WHENEVER Statement

This statement allows you to do automatic error checking and handling. The syntax is:

    EXEC SQL WHENEVER <condition> <action>;

Oracle automatically checks SQLCA for <condition>, and if such condition is detected, your program will automatically perform <action>.<condition> can be any of the following:

SQLWARNING - sqlwarn[0] is set because Oracle returned a warning
SQLERROR - sqlcode is negative because Oracle returned an error
NOT FOUND - sqlcode is positive because Oracle could not find a row that meets your WHERE condition, or a SELECT INTO or FETCH returned no rows

<action> can be any of the following:

CONTINUE - Program will try to continue to run with the next statement if possible
DO - Program transfers control to an error handling function
GOTO <label> - Program branches to a labeled statement
STOP - Program exits with an exit() call, and uncommitted work is rolled back

Some examples of the WHENEVER statement:

    EXEC SQL WHENEVER SQLWARNING DO print_warning_msg();
    EXEC SQL WHENEVER NOT FOUND GOTO handle_empty;

Here is a more concrete example:

/* code to find student name given id */
/* ... */
for (;;) {
    printf("Give student id number : ");
    scanf("%d", &id);
    EXEC SQL WHENEVER NOT FOUND GOTO notfound;
    EXEC SQL SELECT studentname INTO :st_name
             FROM   student
             WHERE  studentid = :id;
    printf("Name of student is %s.\n", st_name);
    continue;
notfound:
    printf("No record exists for id %d!\n", id);
}
/* ... */

Note that the WHENEVER statement does not follow regular C scoping rules. Scoping is valid for the entire program. For example, if you have the following statement somewhere in your program (such as before a loop):EXEC SQL WHENEVER NOT FOUND DO break;
All SQL statements that occur after this line in the file would be affected. Make sure you use the following line to cancel the effect of WHENEVER when it is no longer needed (such as after your loop):
EXEC SQL WHENEVER NOT FOUND CONTINUE;

Demo Programs

Note: The demo programs will create and use four tables named DEPT, EMP, PAY1, and PAY2. Be careful if any table in your database happens to have the same name!Several demo programs are available in /afs/ir/class/cs145/code/proc on the leland system. They are named sample*.pc (for C users) and cppdemo*.pc (for C++ users). ".pc" is the extension for Pro*C code. Do not copy these files manually, since there are a couple of customizations to do. To download and customize the demo programs, follow the instructions below:

Make sure that you have run source /afs/ir/class/cs145/all.env
In your home directory, run load_samples <db_username> <db_passwd> <sample_dir>, where <sample_dir> is the name of the directory where you wish to put demo programs (e.g., load_samples sally etaoinshrdlu cs145_samples)
cd <sample_dir>
Run make samples (or make cppsamples for C++) to compile all demo programs

Step (2) will set up the sample database, create a new directory as specified in <sample_dir>, and copy the demo files into that directory. It will also change the user name and password in the sample programs to be yours, so that you do not have to type in your username and password every time when running a sample program. However, sample1 and cppdemo1 do provide an interface for the user to input the username and password, in case you would like to learn how to do it.If you happen to make any mistake when entering username or password in Step (2), just run clean_samples <db_username> <db_passwd> <sample_dir> in your home directory, and then repeat Steps (2) to (4).
For Step (4), you can also compile each sample program separately. For example, make sample1 compiles sample1.pc alone. The compilation process actually has two phases:

proc iname=sample1.pc

sample1.c

cc <a_number_of_flags_here> sample1.c

sample1

To compile your own code, say, foo.pc, just change a few variables in Makefile: Add the program name foo to variable SAMPLES and the source file name foo.pc to variable SAMPLE_SRC. Then, do make foo afterfoo.pc is ready. foo.pc will be precompiled to foo.c and then compiled to foo, the executable. C++ users will need to add their program name to CPPSAMPLES instead of SAMPLES, and source file name toCPPSAMPLE_SRC instead of SAMPLE_SRC.The demo programs operate on the following tables:

CREATE TABLE DEPT
    (DEPTNO    NUMBER(2) NOT NULL,
     DNAME     VARCHAR2(14),
     LOC       VARCHAR2(13));

CREATE TABLE EMP
    (EMPNO     NUMBER(4) NOT NULL,
     ENAME     VARCHAR2(10),
     JOB       VARCHAR2(9),
     MGR       NUMBER(4),
     HIREDATE  DATE,
     SAL       NUMBER(7, 2),
     COMM      NUMBER(7, 2),
     DEPTNO    NUMBER(2));

CREATE TABLE PAY1
    (ENAME     VARCHAR2(10),
     SAL       NUMBER(7, 2));

CREATE TABLE PAY2
    (ENAME     VARCHAR2(10),
     SAL       NUMBER(7, 2));

These tables are created automatically when you run load_samples in Step (2). A few tuples are also inserted. You may like to browse the tables before running the samples on them. You can also play with them as you like (e.g., inserting, deleting, or updating tuples). These tables will be dropped automatically when you run clean_samples. Note:clean_samples also wipes out the entire <sample_dir>; make sure you move your own files to some other place before running this command!You should take a look at the sample source code before running it. The comments at the top describe what the program does. For example, sample1 takes an employee's EMPNO and retrieve the name, salary, and commission for that employee from the table EMP.
You are supposed to study the sample source code and learn the following:

How to connect to Oracle from the host program
How to embed SQL in C/C++
How to use cursors
How to use host variables to communicate with the database
How to use WHENEVER to take different actions on error messages.
How to use indicator variables to detect NULL's in the output

Now, you can use these techniques to code your own database application program. And have fun!

C++ Users

To get the precompiler to generate appropriate C++ code, you need to be aware of the following issues:

Code emission by precompiler. To get C++ code, you need to set the option CODE=CPP while executing proc. C users need not worry about this option; the default caters to their needs.

Parsing capability. The PARSE option of proc may take the following values:

PARSE=NONE. C preprocessor directives are understood only inside a declare section, and all host variables need to be declared inside a declare section.
PARSE=PARTIAL. C preprocessor directives are understood; however, all host variables need to be declared inside a declare section.
PARSE=FULL. C preprocessor directives are understood and host variables can be declared anywhere. This is the default when CODE is anything other than CPP; it is an error to specify PARSE=FULL withCODE=CPP.

PARSE=NONE

PARSE=PARTIAL

declare sections

    EXEC SQL BEGIN DECLARE SECTION;
        // declarations...
    EXEC SQL END DECLARE SECTION;

File extension. You need to specify the option CPP_SUFFIX=cc or CPP_SUFFIX=C.

Location of header files. By default, proc searches for header files like stdio.h in standard locations. However, C++ has its own header files, such as iostream.h, located elsewhere. So you need to use theSYS_INCLUDE option to specify the paths that proc should search for header files.

List of Embedded SQL Statements Supported by Pro*C

Declarative Statements
`EXEC SQL ARRAYLEN`	To use host arrays with PL/SQL
`EXEC SQL BEGIN DECLARE SECTION` `EXEC SQL END DECLARE SECTION`	To declare host variables
`EXEC SQL DECLARE`	To name Oracle objects
`EXEC SQL INCLUDE`	To copy in files
`EXEC SQL TYPE`	To equivalence datatypes
`EXEC SQL VAR`	To equivalence variables
`EXEC SQL WHENEVER`	To handle runtime errors
Executable Statements
`EXEC SQL ALLOCATE`	To define and control Oracle data
`EXEC SQL ALTER`
`EXEC SQL ANALYZE`
`EXEC SQL AUDIT`
`EXEC SQL COMMENT`
`EXEC SQL CONNECT`
`EXEC SQL CREATE`
`EXEC SQL DROP`
`EXEC SQL GRANT`
`EXEC SQL NOAUDIT`
`EXEC SQL RENAME`
`EXEC SQL REVOKE`
`EXEC SQL TRUNCATE`
`EXEC SQL CLOSE`
`EXEC SQL DELETE`	To query and manipulate Oracle data
`EXEC SQL EXPLAIN PLAN`
`EXEC SQL FETCH`
`EXEC SQL INSERT`
`EXEC SQL LOCK TABLE`
`EXEC SQL OPEN`
`EXEC SQL SELECT`
`EXEC SQL UPDATE`
`EXEC SQL COMMIT`	To process transactions
`EXEC SQL ROLLBACK`
`EXEC SQL SAVEPOINT`
`EXEC SQL SET TRANSACTION`
`EXEC SQL DESCRIBE`	To use dynamic SQL
`EXEC SQL EXECUTE`
`EXEC SQL PREPARE`
`EXEC SQL ALTER SESSION`	To control sessions
`EXEC SQL SET ROLE`	To control sessions
`EXEC SQL EXECUTE` `END-EXEC`	To embed PL/SQL blocks

Source :- http://infolab.stanford.edu/~ullman/fcdb/oracle/or-proc.html

Resume tips by a 15 years recruiter at google.

2012-09-07T00:09:00.002-07:00

What Resume Screeners Look For
Resume screeners look for the same things that interviewers do:
»»Are you smart?
»»Can you code?
That means that you should present your resume to show those two things. Your love of tennis, traveling, or magic cards won’t do much to show that, so it’s likely just wasting space.
Keep in mind that recruiters only spend a fixed amount of time (about 20 seconds) looking at your resume. If you limit the content to the best, most impressive, most relevant items, they’ll jump out at the recruiter. Weak items only dilute your resume and distract the recruiter
from what you’d like them to see.
Employment History
Relevant Jobs: Your resume does not - and should not - include a full history of every role you’ve ever had. Your job serving ice cream, for example, will not show that you’re smart or that you can code. Include only the relevant things.
Writing Strong Bullets: For each role, try to discuss your accomplishments with the following approach: “Accomplished
X by implementing Y which led to Z.” Here’s an example:
»»“Reduced object rendering time by 75% by applying Floyd’s algorithm,
leading to a 10% reduction in system boot time.”
Here’s another example with an alternate
wording:
»»“Increased average match accuracy
from 1.2 to 1.5 by implementing
a new comparison algorithm based on windiff.”
Not everything you did will fit into this approach, but the principle is the
Got some extra time to prepare?
If you have at least a couple months before an interview (or if you’re in school and not graduating yet), you may be able to improve your resume.
Go out and get project experience! Take course that have major projects. Get involved in open source. Ask a professor if there is any research you can get involved in, or ask if he/she can sponsor you on an independent study.
This will put you in a better position to have your resume selected down the road. It will also give you lots of things to talk about in an interview.

same: show what you did, how you did it, and what the results were. Ideally, you should try to make the results “measurable” somehow.
Projects
Almost every candidate has some projects, even if they’re just academic projects. List them on your resume! I recommend putting a section called “Projects” on your resume and list your 2 - 4 most significant projects. State what the project was, which languages or technologies
it employed, and whether it was an individual or a team project. If your project was not for a course, that’s even better! It shows passion, initiative, and work ethic. You can state the type of project by listing course projects as “Course Project” and your independent projects as “Independent Projects” (or some other wording).
Programming Languages and Software
Software: Generally speaking, I do not recommend listing that you’re familiar with Microsoft Office. Everyone is, and it just dilutes the “real” information. Familiarity with developer-specific
or highly technical software (e.g., Visual Studio, Eclipse, Linux) can be useful, but it often doesn’t make much of a difference.
Languages: Knowing which languages to list on your resume is always a tricky thing. Do you list everything you’ve ever worked with? Or only the ones that you’re more comfortable with (even though that might only be one or two languages)? I recommend the following compromise: list most languages you’ve used, but add your experience level. This approach is shown below:
»»“Languages: Java (expert), C++ (proficient), JavaScript (prior experience), C (prior experience)”
Advice for Non-Native English Speakers and Internationals
Proofreading: Some companies will throw out your resume just because of a typo. Please get at least one native English speaker to proofread your resume.
Personal Information: For US positions, do not include age, marital status, or nationality. This sort of personal information is not appreciated by companies, as it creates a legal liability
for them. However, you may want to include your current work authorization / visa status, particularly when applying to smaller companies who may be unable to sponsor candidates.

Reference to C Quiz.

2012-09-05T22:12:00.000-07:00

Following are the references for some C quiz websites.
Point of giving you the link is something different.
I want you to take quiz from there.
In case you come across a problem in any question, simply post the link to that question or Copy/Paste the question here.
1.http://www.freeaptitude.com/tag/c-programming-tricky-questions
2.http://leebaannvarghes.hubpages.com/hub/Some-tricky-programming-questions-for-interview
3.http://www.cprogrammingreference.com/questionbank_home.html

Don't forget to hit the like button

TCS technical interview questions

2012-09-05T03:20:00.000-07:00

Q:What will be the output of the following code?

void main ()

{ int i = 0 , a[3] ;

a[i] = i++;

printf (“%d”,a[i]) ;

}

Ans: The output for the above code would be a garbage value. In the statement a[i] = i++; the value of the variable i would get assigned first to a[i] i.e. a[0] and then the value of i would get incremented by 1. Since a[i] i.e. a[1] has not been initialized, a[i] will have a garbage value.

Q:Why doesn’t the following code give the desired result?

A: int x = 3000, y = 2000 ;

long int z = x * y ;

Ans: Here the multiplication is carried out between two ints x and y, and the result that would overflow would be truncated before being assigned to the variable z of type long int. However, to get the correct output, we should use an explicit cast to force long arithmetic as shown below:

long int z = ( long int ) x * y ;

Note that ( long int )( x * y ) would not give the desired effect.

Q: Why doesn’t the following statement work?

A: char str[ ] = “Hello” ;

strcat ( str, ‘!’ ) ;

Ans: The string function strcat( ) concatenates strings and not a character. The basic difference between a string and a character is that a string is a collection of characters, represented by an array of characters whereas a character is a single character. To make the above statement work writes the statement as shown below:

strcat ( str, “!” ) ;

Q:How do I know how many elements an array can hold?

A: The amount of memory an array can consume depends on the data type of an array. In DOS environment, the amount of memory an array can consume depends on the current memory model (i.e. Tiny, Small, Large, Huge, etc.). In general an array cannot consume more than 64 kb. Consider following program, which shows the maximum number of elements an array of type int, float and char can have in case of Small memory model.

main( )

{

int i[32767] ;

float f[16383] ;

char s[65535] ;

}

Q:How do I write code that reads data at memory location specified by segment and offset?

A: Use peekb( ) function. This function returns byte(s) read from specific segment and offset locations in memory. The following program illustrates use of this function. In this program from VDU memory we have read characters and its attributes of the first row. The information stored in file is then further read and displayed using peek( ) function.

#include

main( )

{

char far *scr = 0xB8000000 ;

FILE *fp ;

int offset ;

char ch ;

if ( ( fp = fopen ( “scr.dat”, “wb” ) ) == NULL )

{

printf ( “\nUnable to open file” ) ;

exit( ) ;

}

// reads and writes to file

for ( offset = 0 ; offset < 160 ; offset++ )

fprintf ( fp, “%c”, peekb ( scr, offset ) ) ;

fclose ( fp ) ;

if ( ( fp = fopen ( “scr.dat”, “rb” ) ) == NULL )

{

printf ( “\nUnable to open file” ) ;

exit( ) ;

}

// reads and writes to file

for ( offset = 0 ; offset < 160 ; offset++ )

{

fscanf ( fp, “%c”, &ch ) ;

printf ( “%c”, ch ) ;

}

fclose ( fp ) ;

}

Q: What is C language?

A: The C programming language is a standardized programming language developed in the early 1970s by Ken Thompson and Dennis Ritchie for use on the UNIX operating system. It has since spread to many other operating systems, and is one of the most widely used programming languages. C is prized for its efficiency, and is the most popular programming language for writing system software, though it is also used for writing applications.

Q: Inprintf() Function What is the output of printf(“%d”)?

A:1. When we write printf(“%d”,x); this means compiler will print the value of x. But as here, there is nothing after ï¿½%dï¿½ so compiler will show in output window garbage value.

2. When we use %d the compiler internally uses it to access theargument in the stack (argument stack). Ideally compiler determines the offset of the data variable depending on the format specification string. Now when we write printf(“%d”,a) then compiler first accesses the top most element in the argument stack of the printf which is %d and depending on the format string it calculated to offset to the actual datavariable in the memory which is to be printed. Now when only %d will be present in the printf then compiler will calculate the correct offset (which will be the offset to access the integer variable) but as the actual data object is to be printed is not present at that memory location so it will print what ever will be the contents of that memory location.

3. Some compilers check the format string and will generate an error without the proper number and type of arguments for things like printf(…) and scanf(…).

Q:malloc() Function- What is the difference between “calloc(…)” and “malloc(…)”?

A:1. calloc(…) allocates a block of memory for an array of elements of a certain size. By default the block is initialized to 0. The total number of memory allocated will be (number_of_elements * size).

malloc(…) takes in only a single argument which is the memory required in bytes. malloc(…) allocated bytes of memory and not blocks of memory like calloc(…).

2. malloc(…) allocates memory and returns a void pointer to the allocated space, or NULL if there is insufficient memory available.

calloc(…) allocates an array in memory with elements initialized to 0 and returns a pointer to the allocated space .

Q: In printf() Function- What is the difference between “printf(…)” and “sprintf(…)”?

A: sprintf(…) writes data to the character array whereas printf(…) writes data to the standard output device.

Q:Compilation How to reduce a final size of executable?

A:Size of the final executable can be reduced using dynamic linking for libraries.

Made it to amdocs

2012-09-04T22:47:00.001-07:00

Finally my blog helped me a lot.
Most of the questions I was asked were there on my blog.
Hope it will help you too.Be a part of it and discuss with us any question you wanna ask

Why ++i is faster than i++?

2012-08-27T06:49:00.003-07:00

It is a very common question asked in most of the interviews. That's why I am not writing the name of any specific company.

It is true that prefix operator is faster than postfix operator because in case of postfix operator
Value of variable is copied in memory , operation is performed and then increment is done.
While in case of prefix operator no extra storage is needed.
Hence it is memory extensive and faster as compare to postfix operator.
But use prefix operator with care.

GUYS IF YOU REALLY LIKE THE POSTS OF THIS BLOG THEN PLEASE JOIN OUR BLOG.
AND HELP US TO PUT MORE POSTS LIKE THIS.
PLEASE HIT THE LIKE BUTTON BELOW

AMDOCS: Predict the output

2012-08-26T22:37:00.002-07:00

#include <stdio.h>

int main(void)
{
   int a, b, c, d;
   a = 3;
   b = 5;
   c = a, b;
   d = (a, b);

   printf("c=%d  ", c);
   printf("d=%d\n", d);

   return 0;
}

TCS: Predict the output

2012-08-26T00:17:00.002-07:00

main()

{

char *p;

printf("%d %d ",sizeof(*p),sizeof(p));

}

Answer:

1 2

Explanation:

The sizeof() operator gives the number of bytes taken by its operand. P is a character pointer, which needs one byte for storing its value (a character). Hence sizeof(*p) gives a value of 1. Since it needs two bytes to store the address of the character pointer sizeof(p) gives 2.

Pacenet: getchar() andputchar() in C are functions or macros? and Why?

2012-08-22T06:05:00.002-07:00

Most C implementations impose a significant overhead for
each function call. Thus we may want to define things that look like
functions but do not have the function call overhead.
Due to which
getchar() and putchar() are usually implemented as macros to avoid having
to call a function for each character of input or output.

Linker: What does an exe file means in C?

2012-08-21T11:17:00.002-07:00

An important idea in C is separate compilation: several programs can be

compiled at different times and bound together. But the linker is

separate from the C compiler and can't know too much about the details

of C; how can it know how to combine C programs? Although linkers

don't understand C, they do understand machine language and memory

layout, and it is up to each C compiler to translate C programs into terms

that make sense to the linker.

A typical linker combines several object modules produced by a compiler

or assembler together into a single entity, sometimes called a load

module or an executable file, that the operating system can execute directly.

Some of those object modules are given directly as input to the linker;

others are fetched on demand from a library of object modules containing

printf and similar things.

A linker typically views an object module as containing a collection of

external objects. Each external object represents the contents of some part

of the machine's memory and is identified by an external name. Thus

every function not declared static is an external object, as is every

external variable not declared static. Some implementations make

static functions and variables into external objects as well by

transforming their names somehow so that they do not clash with identically

named variables in other source program files.

Most linkers forbid two different external objects in a single load

module to have the same name. However, several object modules to be

combined into a single load module might contain identically-named

external objects. One important job of a linker is to handle these name

conflicts.

The simplest way to handle such a conflict is to prohibit it. This is

surely correct if the external objects are functions: a program that contains

two different functions with the same name should be rejected. The

problem is harder, though, if the objects are variables. Different linkers

handle that situation in different ways;

Who Killed the Software Engineer? (Hint: It Happened in College)

2012-08-20T11:34:00.000-07:00

Reference :- http://www.datamation.com/career/article.php/11067_3722876_1#

I know it is a very old article, but every guy must know about it.
All those who say c language's scope is diminishing.

A conversation with Robert Dewar is enough to make you wonder about the future of the American software engineer. Dewar, a professor emeritus of computer science at New York University, believes that U.S. colleges are turning out programmers who are – there’s no nice way to say this – essentially incompetent.

To support his claim, Dewar penned a scathing broadside decrying today’s college-level computer science training. (The article was co-authored by Edmond Schonberg, also a CS professor emeritus at NYU.) Entitled Computer Science Education: Where are the Software Engineers of Tomorrow?, the widely read article has prompted heated discussion throughout the tech industry.

Robert Dewar
Professor emeritus, NYU

To sum up Dewar’s argument: today’s college computer science programs aren’t rigorous enough, and don’t promote in-depth thinking and problem solving. Instead, in an effort to boost enrollment, CS programs focus on easily accessible curricula, and so fail to prepare students to compete with their international peers.

One of the article’s main points (one that was misunderstood, Dewar tells me) is that the adoption of Java as a first programming language in college courses has led to this decline. Not exactly. Yes, Dewar believes that Java’s graphic libraries allow students to cobble together software without understanding the underlying source code.

But the problem with CS programs goes far beyond their focus on Java, he says.

“A lot of it is, ‘Let’s make this all more fun.’ You know, ‘Math is not fun, let’s reduce math requirements. Algorithms are not fun, let’s get rid of them. Ewww – graphic libraries, they’re fun. Let’s have people mess with libraries. And [forget] all this business about ‘command line’ – we’ll have people use nice visual interfaces where they can point and click and do fancy graphic stuff and have fun."

Dewar says his email in-box is crammed full of positive responses to his article, from students as well as employers. Many readers have thanked him for speaking up about a situation they believe needs addressing, he says.

One email was from an IT staffer who is working with a junior programmer. The older worker suggested that the young engineer check the call stack to see about a problem, but unfortunately, “he’d never heard of a call stack.”

A program which produces its own source code as its output?

2012-08-19T00:49:00.001-07:00

#include<stdio.h>
#include<conio.h>
int main(){
clrscr();
FILE *fp;
char c;

fp = fopen(__FILE__,"r");

do{
c= getc(fp);
putchar(c);
}
while(c!=EOF);

fclose(fp);
getch();
return 0;
}

Tutorial:Memory Allocation in C

2012-08-18T07:19:00.001-07:00

In this chapter, we'll meet malloc, C's dynamic memory allocation function, and we'll cover dynamic memory allocation in some detail.
As we begin doing dynamic memory allocation, we'll begin to see (if we haven't seen it already) what pointers can really be good for. Many of the pointer examples in the previous chapter (those which used pointers to access arrays) didn't do all that much for us that we couldn't have done using arrays. However, when we begin doing dynamic memory allocation, pointers are the only way to go, because what malloc returns is a pointer to the memory it gives us. (Due to the equivalence between pointers and arrays, though, we will still be able to think of dynamically allocated regions of storage as if they were arrays, and even to use array-like subscripting notation on them.)
You have to be careful with dynamic memory allocation. malloc operates at a pretty ``low level''; you will often find yourself having to do a certain amount of work to manage the memory it gives you. If you don't keep accurate track of the memory which malloc has given you, and the pointers of yours which point to it, it's all too easy to accidentally use a pointer which points ``nowhere'', with generally unpleasant results. (The basic problem is that if you assign a value to the location pointed to by a pointer:

 *p = 0;

and if the pointer p points ``nowhere'', well actually it can be construed to point somewhere, just not where you wanted it to, and that ``somewhere'' is where the 0 gets written. If the ``somewhere'' is memory which is in use by some other part of your program, or even worse, if the operating system has not protected itself from you and ``somewhere'' is in fact in use by the operating system, things could get ugly.)

A problem with many simple programs, including in particular little teaching programs such as we've been writing so far, is that they tend to use fixed-size arrays which may or may not be big enough. We have an array of 100 ints for the numbers which the user enters and wishes to find the average of--what if the user enters 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. Here's the first step:

 #include <stdlib.h>

 char *line;
 int linelen = 100;
 line = malloc(linelen);
 /* incomplete -- malloc's return value not checked */
 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 ofmalloc 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 = malloc(15);
 /* incomplete -- malloc's return value not checked */
 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 callingmalloc:

 char *somestring, *copy;
 ...
 copy = malloc(strlen(somestring) + 1);  /* +1 for \0 */
 /* incomplete -- malloc's return value not checked */
 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 callingmalloc. To allocate space for 100 ints, we could call

 int *ip = 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(100000000), 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. (As we said in section 9.4, a null pointer can be used as a failure return from a function that returns pointers, and malloc is a perfect example.) 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 = malloc(100 * sizeof(int));
 if(ip == NULL)
  {
  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.)

BeginnerLevel: Order of evaluation of following expression? a < b && c < d

2012-08-17T03:33:00.002-07:00

(expression1) < (expression2) && (expression3) < (expression4)

For such type of expressions , you must have a sound knowledge of precedence table.

But this is an easiest example.

We know that '<' operator has higher precedence than '&&' .

Hence first of all '<' will be executed.

But there is not surety whether expression1 will be executed first or expression 2.

The result of first '<' will decide whether expression after '&&' will get executed or not.

If the result of first '<' is false the second '<' will not get executed. Else the same procedure will be followed for expression after '&&'

GUYS IF YOU REALLY LIKE THE POSTS OF THIS BLOG THEN PLEASE JOIN OUR BLOG.

AND HELP US TO PUT MORE POSTS LIKE THIS.

PLEASE HIT THE LIKE BUTTON ON RIGHT HAND SIDE.

Beginner level: %g,%e,%E,%G in C

2012-08-16T22:34:00.000-07:00

GUYS IF YOU REALLY LIKE THE POSTS OF THIS BLOG THEN PLEASE JOIN OUR BLOG.
AND HELP US TO PUT MORE POSTS LIKE THIS.
PLEASE HIT THE LIKE BUTTON ON RIGHT HAND SIDE.

printf()

Syntax:

#include <stdio.h>
int printf( const char *format, ... );

Description:
The printf() function prints output to STDOUT, according to format and other arguments passed to printf(). The string format consists of two types of items - characters that will be printed to the screen, and format commands that define how the other arguments to printf() are displayed. Basically, you specify a format string that has text in it, as well as "special" characters that map to the other arguments of printf().

The %s means, "insert the first argument, a string, right here." The %d indicates that the second argument (an integer) should be placed there. There are different %-codes for different variable types, as well as options to limit the length of the variables and whatnot.

Code  Format

----    ------

%c  character

%d  signed integers

%i  signed integers

%e  scientific notation, with a lowercase "e"

%E  scientific notation, with a uppercase "E"

%f  floating point

%g  use %e or %f, whichever is shorter

%G  use %E or %f, whichever is shorter

%o  octal

%s  a string of characters

%u  unsigned integer

%x  unsigned hexadecimal, with lowercase letters

%X  unsigned hexadecimal, with uppercase letters

%p  a pointer

%n  the argument shall be a pointer to an integer into which is placed the number of characters written so far

%%  a '%' sign

An integer placed between a % sign and the format command acts as a minimum field width specifier, and pads the output with spaces or zeros to make it long enough. If you want to pad with zeros, place a zero before the minimum field width specifier. You can use a precision modifier, which has different meanings depending on the format code being used.

With %e, %E, and %f, the precision modifier lets you specify the number of decimal places desired. For example,
```
%12.6f
```
will display a floating number at least 12 digits wide, with six decimal places.

With %g and %G, the precision modifier determines the maximum number of significant digits displayed.

With %s, the precision modifer simply acts as a maximumfield length, to complement the minimum field length that precedes the period.

All of printf()'s output is right-justified, unless you place a minus sign right after the % sign. For example,

    %-12.4f

will display a floating point number with a minimum of 12 characters, 4 decimal places, and left justified. You may modify the %d, %i, %o, %u, and %x type specifiers with the letter l and the letter h to specify long and short data types (e.g. %hd means a short integer). The %e, %f, and %g type specifiers can have the letter l before them to indicate that a double follows. The %g, %f, and %e type specifiers can be preceded with the character '#' to ensure that the decimal point will be present, even if there are no decimal digits. The use of the '#' character with the %x type specifier indicates that the hexidecimal number should be printed with the '0x' prefix. The use of the '#' character with the %o type specifier indicates that the octal value should be displayed with a 0 prefix.

You can also include constant escape sequences in the output string.

The return value of printf() is the number of characters printed, or a negative number if an error occurred.

Example:

char name[20] = "Bob";
int age = 21;
printf( "Hello %s, you are %d years old\n", name, age );

OUTPUT: Hello Bob, you are 21 years old

google:Why index of array always starts from 0

2012-08-16T05:17:00.004-07:00

A simple question to all programmers that why the index of an array starts from 0 instead from 1.
was it a mistake of compiler designer in history or it has some reason behind it.
Obviously it has a reason behind it. What is that reason?

Being honest to yourself, If you don't know the answer , Please join our site and contribute to society

Yaho!: Easiest question ever(judge the output)

2012-08-15T21:52:00.000-07:00

What should be the output of this program?

void main()
{
int y=5,z=6;
if(y || ++z)
{
printf("\ny=%d",y);
printf("z=%d",z);

}

}

output:

y= ?(guess)
z=?(guess)

Amazon: You are probably the master of C, if you can answer this beginner level question

2012-08-15T11:37:00.000-07:00

Why we use inclusive lower bond and exclusive upper bond for array?
confused?

i.e why we see this syntax

int a[10];
for(i=0;i<10;i++)

instead of

int a[10];
for(i=0;i<=9;i++)

Being faithful to your inner soul, If you don't know the answer, join our site and subscribe for latest updates.

And don't forget to ask the answer of this question.

C related books

2012-08-12T12:16:00.000-07:00

A list of all C good books

All C books

Difference between float g( ); and (h)( );

2012-08-12T10:46:00.001-07:00

float *g(), (*h)();

Here g( ) is function returning a pointer to a float type value

Whereas (*h) is a pointer type variable pointing to a function.

Being honest guys If you didn't know the answer ,join our site. We are doing our best for it.

We try to find questions from around 10 best books Of C.

So contribute to us and be a part of our C family.

TCS: Post the output of following statement :- a+++++b

2012-08-12T10:03:00.000-07:00

What should be the output of the following code if we print, like

void main()
{

int a=4,b=3,x;
x=a+++++b;
printf("Value of x is :%d", x);

}

----------------------------------

Being honest, If you dont know the answer join our site for all latest questions like this.

Have fun!!

Apple: In which case exit() and return() function works in same manner?

2012-08-11T04:29:00.004-07:00

The exit() function is used to exit your program and return control
to the operating system. The return statement is used to return from a
function and return control to the calling function. If you issue a return
from the main() function, you are essentially returning control to the
calling function, which is the operating system. In this case, the return
statement and exit() function are similar.