0
C Programming
Questions related to the C Computer Programming Language. This ranges all the way from K&R to the most recent ANSI incarnations. C has become one of the most popular languages today, and has been used to write all sorts of things for nearly all of the modern operating systems and applications. It it a good compromise between speed, power, and complexity.
9,649 Questions
in C: a semicolon in itself. Examples:
1. while (*to++ = *from++);
2. { goto END; ... END:; }
Where can someone find a list of C Compilers?
One can find a list of C Compilers, along with helpful information at several online sites. Some of these online sites with this information are "Cplus" and "Delorie".
Can a machine having 64MB run an executable which is 300MB using far pointers?
Yes, but you will incur a substantial penalty in virtual address page fault rates. Also, the standard page overcommit ratio in Windows is 4 to 1, so you would only be able to have a 256MB address space.
What is the declaration of overloaded pre-increment operator implemented as member function?
The pre-increment operator accepts no parameters and returns the same object (by reference) after incrementing.
The post-increment operator accepts an unused (dummy) integer parameter and returns a copy of the object (by value) that is made immediately prior to incrementing the object.
Note that it is good practice to always use the pre-increment operator even if a post-increment operator exists. The only time you should ever use a post-increment is when you actually store the return value. If you don't store the return value then you will end up making an unnecessary copy, which is highly inefficient. With primitive data types that are less than or equal in length to a pointer this isn't a major issue, but it's good practice nonetheless. If you do it for primitives then you're far more likely to remember to do it for class instances as well.
The following example emulates an integer type with pre-increment and post-increment operators implemented:
class Simple
{
public: // Construction:
Simple(int data = 0):m_data(data){}
Simple(const Simple& simple):m_data(simple.m_data){}
public:
// Assignment:
Simple& operator= (const Simple& simple) {
m_data = simple.m_data;
return( *this ); }
// pre-increment:
Simple& operator++ () { // no parameters!
++m_data; // increment this object
return( *this ); } // return a reference to this object
// post-increment:
Simple operator++(int) { // int parameter (not used)!
Simple copy( *this ); // call the copy constructor
++m_data; // increment this object
return( copy ); } // return the copy (by value)
private:
int m_data;
};
How do you implement a deque using an array in c language?
A deque (pronounced deck) is a double-ended queue where objects can be efficiently pushed to and popped from either end of the queue.
Arrays are not ideally suited to this task because arrays operate more efficiently when used like a stack, pushing and popping elements at the end of the array where the unused elements are. When we run out of unused elements we can reallocate the array creating more space at the end as required (typically doubling the allocation with each reallocation). For this we need to keep track of three pieces of information:
- The start address of the array.
- The overall length of the array in elements (size).
- The number of unused elements at the end of the array (space).
A queue differs from a stack in that all insertions occur at the first unused element, while extractions occur at the first used element, which is initially at the start of the array. After an extraction we end up with an unused element at the start of the array. Although we could shunt all used elements by one element to eliminate the gap, it is more efficient to just keep track of the front of the queue. Thus we need 4 pieces of information:
- The start address of the array.
- The overall length of the array in elements (size).
- The total number of unused elements in the array (space).
- The index of the first element in the queue (start).
From this information it is trivial to calculate the length of the queue (size-space) and thus determine where the first unused element is using modulo arithmetic: ((start+(size-space))%size).
When we run out of space at the end of the array for an insertion, we simply use the unused elements at the beginning of the array. When we run out of space completely, we normalise the array so that the start of the queue is back at the beginning of the array before reallocating the array, thus placing all the new unused elements at the end of the array (after the last element in the queue). If we don't normalise the array, we will most likely end up with unused elements in the middle of the queue due to the circular nature of the array.
To implement a deque we use a similar technique except we can insert and extract from either end of the queue. The following program demonstrates how the major deque operations can be implemented upon an array of unsigned integers.
#include
#include
#include
#include
// a deque of unsigned integers
typedef struct arraydeque_t {
unsigned* arr; // pointer to a variable length array of type unsigned
unsigned sz; // overall length of array (in elements)
unsigned space; // unused elements
unsigned start; // index of the start of the queue
} arraydeque;
bool is_empty (arraydeque*);
unsigned size (arraydeque*);
unsigned back (arraydeque*);
unsigned front (arraydeque*);
int initialise (arraydeque*);
int push_back (arraydeque*, unsigned);
int push_front (arraydeque*, unsigned);
int expand (arraydeque*);
void pop_back (arraydeque*);
void pop_front (arraydeque*);
void clear (arraydeque*);
// calculates and returns the length of the queue
unsigned size (arraydeque* deq) {
return deq->sz-deq->space;
}
// returns true if the queue is empty
bool is_empty (arraydeque* deq) {
return deq->space==deq->sz;
}
// clear the deque
void clear (arraydeque* deq) {
if (deq->arr) free (deq->arr);
memset (deq, 0, sizeof (arraydeque));
}
// initialise the deque
int initialise (arraydeque* deq) {
const unsigned sz = 1; // start with 2 unused elements
memset (deq, 0, sizeof (arraydeque));
deq->arr = (unsigned*) malloc (sz * sizeof (unsigned));
if (!deq->arr) return -1; // out of memory
deq->sz = sz;
deq->space = sz;
return 0;
}
// increase the size of the deque (create space)
int expand (arraydeque* deq) {
unsigned space, t, i, *p;
if (deq->space) return 0; // no need to expand when we have space
// normalise the array (realign the start of the queue with the start of the array
while (deq->start) {
t = deq->arr[0]; // temporarily store first element value
for (i=1; i
deq->arr[i-1] = deq->arr[i];
deq->arr[deq->sz-1] = t; // put temporary value at end of array
--deq->start;
}
// reallocate the array to create space after the queue
space = (unsigned) (0.6 * deq->sz + 1); // optimum growth: 160%
p = (unsigned*) realloc (deq->arr, (deq->sz + space) * sizeof(unsigned));
if (!p) return -1; // out of memory
deq->arr = p;
deq->sz += space;
deq->space = space;
return 0;
}
// insert value at the back of the queue
int push_back (arraydeque* deq, unsigned val) {
if (expand (deq))
return -1; // out of memory
deq->arr[(deq->start+size (deq))%deq->sz] = val;
--deq->space;
return 0;
}
// insert value at the front of the queue
int push_front (arraydeque* deq, unsigned val) {
if (expand (deq))
return -1; // out of memory
if (!deq->start)
deq->start=deq->sz;
--deq->start;
deq->arr[deq->start] = val;
--deq->space;
return 0;
}
// extract the back value
void pop_back (arraydeque* deq) {
++deq->space;
}
// extract the front value
void pop_front (arraydeque* deq) {
++deq->start;
deq->start%=deq->sz;
++deq->space;
}
// return the back value
unsigned back (arraydeque* deq) {
return deq->arr[((deq->start + size(deq)-1)%deq->sz)];
}
// return the front value
unsigned front (arraydeque* deq) {
return deq->arr[deq->start];
}
// returns true or false at random (used by test program)
bool is_true (void) {
return rand() & 0x1;
}
// prints the content of the deque (used by test program)
void print_queue (arraydeque* deq) {
unsigned i, sz;
printf ("{");
sz = size (deq);
i = deq->start;
while (sz--) {
printf ("%u%s", deq->arr[i++], sz?", ":"");
if (i==deq->sz) i=0;
}
printf ("}\n");
}
// test program
int main (void) {
unsigned i, loop;
srand((unsigned) time(0)); // seed random generator
arraydeque deq;
initialise (&deq); // initialise the deque
for (loop=0; loop<100; ++loop) {
if (is_true ()) {
i = rand() % 10;
if (is_true ()) {
printf ("Pushing %d to the front:\t\t", i);
if (push_front (&deq, i))
break; // out of memory
}else{
printf ("Pushing %d to the back:\t\t", i);
if (push_back (&deq, i))
break; // out of memory
}
print_queue (&deq);
}
else if (is_true() && !is_empty (&deq)) {
if (is_true ()) {
printf ("Popping %u from the front:\t", front (&deq));
pop_front (&deq);
}else{
printf ("Popping %u from the back:\t", back (&deq));
pop_back (&deq);
}
print_queue (&deq);
}
}
while (!is_empty(&deq)) {
if (is_true ()) {
printf ("Popping %u from the front:\t", front (&deq));
pop_front (&deq);
}else{
printf ("Popping %u from the back:\t", back (&deq));
pop_back (&deq);
}
print_queue (&deq);
}
clear (&deq);
return 0;
}
C program to find address of variable?
// Use the & operator (Sometimes called the "address of" operator
int variable = 7;
printf("Address of variable = %d\n", &variable);
printf("Value of variable = %d\n", variable);
How do you programme 1 232 34543 232 1 in C?
int main (void)
{
puts ("1 232 34543 232 1");
return 0;
} int main (void)
{ puts ("1 232 34543 232 1"); return 0; }
WHERE IS THE BEST PLACE TO FIND GOLD IN n.c.?
There is no one best place to find gold in N.C. because there are several mining locations. Among them include Guilford, Orange, Montgomery and Randolph.
Why are Inheritance super classes fragile?
Superclasses are considered fragile because seemingly safe modifications to a super class, when inherited by the derived classes, may cause the derived classes to malfunction.
If you want to use prototype it has to be declared before main(). If you have a function of type double with one argument of type int (with name arg), and the function name is func, then we have:
#include
...
double func(int arg);
...
int main(...)
{
...
return 0;
}
...
double func(int arg)
{
...
}
How is one dimensional and two dimensional arrays read and written?
You go through all the elements of an array with a loop - or, in the case of a 2-dimensional array, with two nested loops. If you have a 10-dimensional array, you would use 10 nested loops. In any case, one variable to keep track of the position for each dimension.
What data type does the main function return in c?
The main function must return the int data type. A program that terminates normally should return the value zero to indicate no error. Not all execution environments make use of the return value (Windows in particular), however a command script or batch file can examine the ERRORLEVEL if required.
What is a valid variable data type?
1. If its natural or integer numbers- Integer(Int) data type. 2. If it consists of decimal or fraction part- Double or float data type. 3. If it has a single letter or sign- Character(Char) data type. 4. If its got many words(alpha-numerical)- String data type. 5. If the result has to be "true" or "false"- Boolean data type.
This is false. The movement described is a disadvantageof bubble sort.
How do you get principal varivation from iterative deepening search?
You will get principal variation from iterative deepening search using sequential moves within the framework. It is important to note that this may slow down the search due to space requirements.Ê
How do you download c plus plus for a mac?
Download Xcode from Apple (you'll need a free developers account), and it allows you to script in C++, along with C, Obj-C, Ruby, Python, and more.
A "Hello world" program is usually the very first program you write when learning a new programming language, it simply prints out the text "Hello World". Below are a few examples:
PHP:
echo "Hello World";
_____________________________________
JavaScript:
document.write("Hello World");
_____________________________________ Visual Basic:
Module Hello
Sub Main()
MsgBox("Hello, World!") ' Display message on computer screen.
End Sub
End Module
What makes a Daewoo 2000 Nubira shift suddenly to the right when accelerating?
I had the same problem. This is the problem. The bushings on the lower right control arm are worn out. These are the GM (remember GM bought Daewoo) part numbers, 96308002 and 96492383. They run about $8.00 a piece. Unless you have hit something very, very hard, your control arms should be fine. A local garage/dealer can put press out the old ones and press the new ones in. That fixed the problem with mine.
AnswerMy opinion on this is that it could be the Throttle Position Sensor also called the TPS. I know this because my car did the same thing and we are having to replace this part. Good Luck! AnswerIt is a front wheel drive car, Yes?Under acceleration, one front tire is getting less grip on the roadway than the other tire is getting, and that is called "torque steer" This is quite normal, and the solution is to back off the gas pedal a bit.
The car is pulling to the right because that right side tire is getting a better grip than the left one is. Just be a little less aggressive on the gas pedal, OK?
AnswerI seriously suggest checking the lower control arms AnswerTyre wear tends to affect this also, mine pulls left under decelration when the tyres are getting down. AnswerCheck right side lower control arm. If accelerate, pulls to right; if deccelerate (not breaking), pulls to left. Install new control arm ASAP! It is not a joke! Same for left side,but the pullings are reversed.You are SO CORRECT! The right lower control arm had a bad bushing in the rear. Thank you very much.
Be aware!! Replace both sides or you will be back to square one before you know it.. (From experience!)
How do you solve josephus problem using circular linked list?
The Josephus problem is a problem to locate the place for the last survivour. It shows the power of the circular linked list over the singly linked lists.
#include <stdio.h>
#include <conio.h>
//Sorting an array with a single FOR loop. No complex coding and testing with multiple array sizes.
int main()
{ clrscr();
int xlist[5]={5,3,4,1,2};
int i,temp;
for (i=0;i<4;)
{
if (xlist[i]<xlist[i+1])
i++;
else
{ temp=xlist[i];
xlist[i]=xlist[i+1];
xlist[i+1]=temp;
i=0;
}
}
for (i=0;i<5;i++)
{ printf("%d ",xlist[i]); }
getch();
return 0;
}
What is the syntax for removing the characters from a string?
There is no need to remove any characters, simply overwrite the first character with a null terminator.
Example:
#include<stdio.h>
void clear_string (char* pstr) {
if (pstr!=0) pstr[0]='\0';
}
int main (void) {
char str[] = "Hello world!";
printf ("\n%s", str); // prints Hello world! on a new line clear_string (str);
printf ("\n%s", str); // prints an empty string
return 0;
}
Note that the character array, str, will effectively contain the character sequence "\0llo World!\0", however the first null-terminator marks the end of the string, so the rest is simply ignored. There is no point in shrinking an array (even a string) unless you absolutely have to, but even then you can only do that with strings allocated on the heap, like so:
#include<stdio.h>
void clear_heap_string (char** ppstr) {
if (ppstr==0 *ppstr==0) return;
char* pstr = realloc (*ppstr, 1 * sizeof(char));
if (pstr==0) return;
pstr[0] = '\0';
*ppstr = pstr;
}
int main (void) {
char* pstr = malloc (13 * sizeof(char));
*pstr = "Hello world!";
printf ("\n%s", pstr); // prints Hello world! on a new line clear_heap_string (&pstr);
printf ("\n%s", pstr); // prints an empty string
free (pstr);
return 0;
}
Note that if the reallocation fails, pstr will still be pointing at the Hello world! string. For that reason it is simpler to just overwrite the first character with a null-terminator, which is always guaranteed to succeed.
What is the function and purpose of cinema?
I've written a Blog about the same topic in relation to some events in my country: http://srijanfoundation.wordpress.com/2007/11/02/chak-de-india-the-non-message/.
Love,
Rahul Dewan
--
http://srijanfoundation.wordpress.com/
http://srijantech.wordpress.com/
http://www.srijan.in
What is a return statement used for?
It means end the function. Functions automatically end when execution reaches the end of the function, but you can return from a function at any point within the function with a return statement.
If the function returns a value to its caller, you must provide a reachable return statement along with the value you wish to return.
