`conio.h` is a C header file used with old MS-DOS compilers to create text user interfaces. Compilers that target other operating systems, such as Linux-based, 32-bit Windows and OS/2, provide equivalent functionality through other header files and libraries.

The `#include &lt;curses.h&gt;` will give you almost all of the functionality provided by `conio.h`.

&quot;ncurses&quot; needs to be installed in the first place.

If you use the Apt package manager: 

    sudo apt-get install libncurses5-dev libncursesw5-dev

If you use `rpm`:

    sudo yum install ncurses-devel ncurses


For `getch`, take a look at the [&quot;NCURSES Programming HOWTO&quot;](http://tldp.org/HOWTO/NCURSES-Programming-HOWTO/scanw.html#GETCHCLASS) article.

The original **conio.h** was implemented by Borland, so its not a part of the C Standard Library nor is defined by POSIX.

[But here is an implementation for Linux][1] that uses ncurses to do the job.


  [1]: http://sourceforge.net/projects/linux-conioh/

That is because it does not exist, since it is bounded to Windows.

Use the standard functions from `&lt;stdio.h&gt;` instead, such as getc

The suggested ncurses library is good if you want to write console-based GUIs, but I don&#39;t think it is what you want.

A popular Linux library which has similar functionality would be [ncurses](http://en.wikipedia.org/wiki/Ncurses).

Can I set any variable in CSS like I want my div height to always be half of width my div scales with the screen size width for div is in percent

    &lt;div class=&quot;ss&quot;&gt;&lt;/div&gt;
   
CSS:

    .ss {
        width:30%;
        height: half of the width;
    }

This 30% width scales with screen resolution

Can I scale a div&#39;s height proportionally to its width using CSS?

I have a LINQ query that looks like the following:

    DateTime today = DateTime.UtcNow;
    var results = from order in context.Orders
                  where ((order.OrderDate &lt;= today) &amp;&amp; (today &lt;= order.OrderDate))
                  select order;

I am trying to learn / understand LINQ. In some cases, I need to add two additional WHERE clauses. In an effort to do this, I&#39;m using:

    if (useAdditionalClauses)
    {
      results = results.Where(o =&gt; o.OrderStatus == OrderStatus.Open)  // Now I&#39;m stuck.
    }

As you can see, I know how to add an additional WHERE clause. But how do I add multiple? For instance, I&#39;d like to add 

`WHERE o.OrderStatus == OrderStatus.Open AND o.CustomerID == customerID`

to my previous query. How do I do this using extension methods?

Thank you!



Multiple WHERE Clauses with LINQ extension methods

&gt; **Possible Duplicate:**  
&gt; [How to implement getch() function of C in Linux?](https://stackoverflow.com/questions/3276546/how-to-implement-getch-function-of-c-in-linux)  

&lt;!-- End of automatically inserted text --&gt;

What is the equivalent `Linux` version of the `conio.h` header file from MS-DOS?

Is there a way to replace its functionality? *e.g. `getch()`*

&gt; I&#39;m using `gcc` and the text editor `Geany` to compile `C` code.



Where is the &lt;conio.h&gt; header file on Linux? Why can&#39;t I find &lt;conio.h&gt;?

> Possible Duplicate: 
> <a href="https://stackoverflow.com/questions/3276546/how-to-implement-getch-function-of-c-in-linux" target="_blank" rel="noopener noreferrer">How to implement getch() function of C in Linux?</a>

What is the equivalent <code>Linux</code> version of the <code>conio.h</code> header file from MS-DOS?
Is there a way to replace its functionality? e.g. <code>getch()</code>
> I'm using <code>gcc</code> and the text editor <code>Geany</code> to compile <code>C</code> code.

Well, I can&#39;t understand when and why it is needed to allocate memory using `malloc`.

Here is my code :

    #include &lt;stdlib.h&gt;
    
    int main(int argc, const char *argv[]) {
    
      typedef struct {
        char *name;
        char *sex;
        int age;
      } student;
    
    
      //Now I can do two things
      student p;
    
      //or
      student *ptr = (student *)malloc(sizeof(student));
    
      return 0;
    }

Why is it needed to allocate memory when I can just use `student p;`?

When and why to use malloc?

I&#39;ve run across some code like this:

    line += addr &amp; 0x3fULL;

Obviously, &#39;U&#39; and &#39;L&#39; are not hex digits.  I&#39;m guessing that the &#39;ULL&#39; at the end of that hex numeric literal means &quot;Unsigned Long Long&quot;  - am I correct?  (this sort of thing is very difficult to google) if so then this is some sort of suffix modifier on the number?

ULL suffix on a numeric literal

In the Linux kernel source code I found this function:

    static int __init clk_disable_unused(void) 
    {
       // some code
    }

Here I can not understand what does `__init` means.

What does __init mean in the Linux kernel code?

I wrote this simple C program:

&lt;!-- language: c --&gt;

    int main() {
        int i;
        int count = 0;
        for(i = 0; i &lt; 2000000000; i++){
            count = count + 1;
        }
    }

I wanted to see how the gcc compiler optimizes this loop (clearly add *1* 2000000000 times should be &quot;add *2000000000* one time&quot;). So:

**gcc test.c** and then `time` on `a.out` gives:

    real 0m7.717s  
    user 0m7.710s  
    sys 0m0.000s  

**$ gcc -O2 test.c**  and then `time on `a.out` gives: 
 
    real 0m0.003s  
    user 0m0.000s  
    sys	0m0.000s  

Then I disassembled both with `gcc -S`. First one seems quite clear:

        .file &quot;test.c&quot;  
        .text  
    .globl main
        .type	main, @function  
    main:
    .LFB0:
        .cfi_startproc
        pushq	%rbp
        .cfi_def_cfa_offset 16
        movq	%rsp, %rbp
        .cfi_offset 6, -16
        .cfi_def_cfa_register 6
        movl	$0, -8(%rbp)
        movl	$0, -4(%rbp)
        jmp	.L2
    .L3:
        addl	$1, -8(%rbp)
        addl	$1, -4(%rbp)
    .L2:
        cmpl	$1999999999, -4(%rbp)
        jle	.L3
        leave
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
    .LFE0:
        .size	main, .-main
        .ident	&quot;GCC: (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2&quot;
        .section	.note.GNU-stack,&quot;&quot;,@progbits

L3 adds, L2 compare `-4(%rbp)` with `1999999999` and loops to L3 if `i &lt; 2000000000`.

**Now the optimized one:**

        .file &quot;test.c&quot;  
        .text
        .p2align 4,,15
    .globl main
        .type main, @function
    main:
    .LFB0:
        .cfi_startproc
        rep
        ret
        .cfi_endproc
    .LFE0:
        .size main, .-main
        .ident &quot;GCC: (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2&quot;
        .section .note.GNU-stack,&quot;&quot;,@progbits

I can&#39;t understand at all what&#39;s going on there! I&#39;ve got little knowledge of assembly, but I expected something like

    addl $2000000000, -8(%rbp)

I even tried with **gcc -c -g -Wa,-a,-ad -O2 test.c** to see the C code together with the assembly it was converted to, but the result was no more clear that the previous one.  

**Can someone briefly explain:**

 1. The **gcc -S -O2** output.
 2. If the loop is optimized as I expected (one sum instead of many sums)?


How does GCC optimize out an unused variable incremented inside a loop?

I don&#39;t have the option to use but OpenGL methods (that is `glxxx()` methods). I need to draw text using gl methods only. After reading the red book, I understand that it is possible only through the `glBitmap()` method. If this is the only possible way, then can any one help me with the pixel array information for all the characters. Is there is any other way to draw text?

How to draw text using only OpenGL methods?

I use `curl` to get some URL response, it&#39;s JSON response and it contains unicode-escaped national characters like **`\u0144 (ń)`** and **`\u00f3 (&#243;)`**. 

How can I convert them to **UTF-8** or any other encoding to save into file?

How to convert \uXXXX unicode to UTF-8 using console tools in *nix

I have a script that has some functions.

Can I run one of the function directly from command line?

Something like this?

    myScript.sh func()

How can I run a function from a script in command line?

I&#39;m trying to install Hadoop on Ubuntu 11.10. I set the `JAVA_HOME` variable in the file `conf/hadoop-env.sh` to: 

    # export JAVA_HOME=/usr/lib/jvm/java-1.6.0-openjdk

and then I execute these commands (Standalone Operation):

    $ mkdir input 
    $ cp conf/*.xml input 
    $ bin/hadoop jar hadoop-examples-*.jar grep input output &#39;dfs[a-z.]+&#39; 
    $ cat output/*

but I have the following error when executing the third command:

&gt; ERROR : JAVA_HOME is not set

Is the `JAVA_HOME` variable not set correctly?

Hadoop: &#171;ERROR : JAVA_HOME is not set&#187;

When I compile C/C++ program with `popen` in `php`... I got this error:

    g++: error trying to exec &#39;cc1plus&#39;: execvp: No such file or directory

but if I run php code in shell.. it works fine..

in Arch Linux..

PHP Code:

&lt;!-- language: lang-php --&gt;

    &lt;?php
        function rfile($fp) {
        $out=&quot;&quot;;
           while (!feof($fp)) {
               $out.= fgets($fp, 1024000);
           }
           return $out;
        }
        $p = popen(&#39;g++ -Wall -g aplusb.cc -o aplusb 2&gt;&amp;1&#39;, &#39;r&#39;);
        $result = rfile($p);
        pclose($p);
        echo $result;
    ?&gt;

thanks

Compile error: &quot;g++: error trying to exec &#39;cc1plus&#39;: execvp: No such file or directory&quot;

There is a laptop on which I have no root privilege. 

onto the machine I have a library installed using `configure --prefix=$HOME/.usr` .

after that, I got these files in `~/.usr/lib` :

    libXX.so.16.0.0
    libXX.so.16
    libXX.so
    libXX.la
    libXX.a

when I compile a program that invokes one of function provided by the library with this command :
`gcc XXX.c -o xxx.out -L$HOME/.usr/lib -lXX`

xxx.out was generated without warning, but when I run it error like this was thrown:

`./xxx.out: error while loading shared libraries: libXX.so.16: cannot open shared object file: No such file or directory` , though `libXX.so.16` resides there.

my clue-less assumption is that `~/.usr/lib` wasn&#39;t searched when xxx.out is invoked.
but what can I do to specify path of .so , in order that xxx.out can look there for .so file?




An addition is when I feed `-static` to gcc, another error happens like this:

    undefined reference to `function_proviced_by_the_very_librar&#39;

It seems `.so` does not matter even though `-L` and `-l` are given to gcc.
what should I do to build a usable exe with that library?

------------------
### For other people who has the same question as I did

I found [a useful article at tldp](http://tldp.org/HOWTO/Program-Library-HOWTO/index.html) about this.

It introduces static/shared/dynamic loaded library, as well as some example code to use them.

How to specify non-default shared-library path in GCC Linux? Getting &quot;error while loading shared libraries&quot; when running

If I come across old code that does `if (!this) return;` in an app, how severe a risk is this? Is it a dangerous ticking time bomb that requires an immediate app-wide search and destroy effort, or is it more like a code smell that can be quietly left in place?

I am not planning on *writing* code that does this, of course. Rather, I&#39;ve recently discovered something in an old core library used by many pieces of our app. 

Imagine a `CLookupThingy` class has a *non-virtual* `CThingy *CLookupThingy::Lookup( name )` member function. Apparently one of the programmers back in those cowboy days encountered many crashes where NULL `CLookupThingy *`s were being passed from functions, and rather than fixing hundreds of call sites, he quietly fixed up Lookup():

    CThingy *CLookupThingy::Lookup( name ) 
    {
       if (!this)
       {
          return NULL;
       }
       // else do the lookup code...
    }
    
    // now the above can be used like
    CLookupThingy *GetLookup() 
    {
      if (notReady()) return NULL;
      // else etc...
    }
    
    CThingy *pFoo = GetLookup()-&gt;Lookup( &quot;foo&quot; ); // will set pFoo to NULL without crashing

I discovered this gem earlier this week, but now am conflicted as to whether I ought to fix it. This is in a core library used by all of our apps. Several of those apps have already been shipped to millions of customers, and it seems to be working fine; there are no crashes or other bugs from that code. Removing the `if !this` in the lookup function will mean fixing thousands of call sites that potentially pass NULL; inevitably some will be missed, introducing new bugs that will pop up randomly over the next *year* of development. 

So I&#39;m inclined to leave it alone, unless absolutely necessary.

Given that it is technically undefined behavior, how dangerous is `if (!this)` in practice? Is it worth man-weeks of labor to fix, or can MSVC and GCC be counted on to safely return?

Our app compiles on MSVC and GCC, and runs on Windows, Ubuntu, and MacOS. Portability to other platforms is irrelevant. The function in question is guaranteed to never be virtual.

**Edit:** The kind of objective answer I am looking for is something like

 - &quot;Current versions of MSVC and GCC use an ABI where nonvirtual members are really statics with an implicit &#39;this&#39; parameter; therefore they will safely branch into the function even if &#39;this&#39; is NULL&quot; or 
 - &quot;a forthcoming version of GCC will change the ABI so that even nonvirtual functions require loading a branch target from the class pointer&quot; or 
 - &quot;the current GCC 4.5 has an inconsistent ABI where sometimes it compiles nonvirtual members as direct branches with an implicit parameter, and sometimes as class-offset function pointers.&quot; 

The former means the code is stinky but unlikely to break; the second is something to test after a compiler upgrade; the latter requires immediate action even at high cost. 

Clearly this is a latent bug waiting to happen, but right now I&#39;m only concerned with mitigating risk on our specific compilers.

How bad is &quot;if (!this)&quot; in a C++ member function?

I&#39;m just wondering what the `-fpermissive` flag does in the g++ compiler? I am getting:

&gt;error: taking address of temporary [-fpermissive]

which I can solve by giving the  `-fpermissive` flag to the compiler. 

**EDIT**:
I just found what was causing the temporary address error part! I&#39;m going to fix that part right now.

What does the fpermissive flag do?

I am sending file from client to server using TCP. To mark the end of the file I like to send file size before the actual data. So I use `stat` system call to find the size of the file. This is of type `off_t`. I like to know how many bytes it occupies so that I can read it properly on the server side. It is defined in the  `&lt;sys/types.h&gt;`. But I do not understand the definition. It just defines `__off_t or _off64_t` to be `off_t`. Where to look for `__off_t`? Also is it convention that `__` is prefixed for most of the things in header files and scares me when I read header files to understand better. How to read a header file better?

    #ifndef __off_t_defined
    # ifndef __USE_FILE_OFFSET64
    typedef __off_t off_t;
    # else
    typedef __off64_t off_t;
    # endif
    # define __off_t_defined
    #endif 

Where to find the complete definition of off_t type?

How come this code

	std::map &lt;std::string , int&gt; m;
    m[&quot;a&quot;]=1;



 compiles with (I&#39;m using MSVC 2010)

    #include &lt;string&gt;
but not with

    #include &lt;string.h&gt;
?


Difference between &lt;string&gt; and &lt;string.h&gt;?

In what cases should we include **cassert**?



In what cases we need to include &lt;cassert&gt;?

Consider a pair of two source files: an interface declaration file (`*.h` or `*.hpp`) and its implementation file (`*.cpp`).

Let the `*.h` file be like the following:

    namespace MyNamespace {
      class MyClass {
      public:
        int foo();
      };
    }

I have seen two different practices for using namespaces in source files:

`*.cpp` showing practice #1:

    #include &quot;MyClass.h&quot;
    using namespace MyNamespace;
    
    int MyClass::foo() { ... }

`*.cpp` showing practice #2:

    #include &quot;MyClass.h&quot;
    namespace MyNamespace {
    
      int MyClass::foo() { ... }
    
    }

**My question:** Are there any differences between these two practices and is one considered better than the other?

C++: Namespaces -- How to use in header and source files correctly?

Which header files provide the intrinsics for the different x86 SIMD instruction set extensions (MMX, SSE, AVX, ...)? It seems impossible to find such a list online. Correct me if I&#39;m wrong.

Content Type	Original Author	Original Content on Stackoverflow
Question	janniks	View Question on Stackoverflow
Solution 1 - C	Sangeeth Saravanaraj	View Answer on Stackoverflow
Solution 2 - C	karlphillip	View Answer on Stackoverflow
Solution 3 - C	Ottavio Campana	View Answer on Stackoverflow
Solution 4 - C	Antoine Gersant	View Answer on Stackoverflow

Where is the <conio.h> header file on Linux? Why can't I find <conio.h>?

C Problem Overview

C Solutions

Solution 1 - C

Solution 2 - C

Solution 3 - C

Solution 4 - C

Multiple WHERE Clauses with LINQ extension methods

Can I scale a div's height proportionally to its width using CSS?

Attributions