I often read this statements on Stack Overflow. Personally, I don&#39;t find any problem with this, unless I am using it in a polymorphic way; i.e. where I have to use `virtual` destructor.

If I want to extend/add the functionality of a standard container then what is a better way than inheriting one? Wrapping those container inside a custom class requires much more effort and is still unclean.

Subclass/inherit standard containers?

This is inspired by [this question][1] and the comments on one particular answer in that I learnt that `strncpy` is not a very safe string handling function in C and that it pads zeros, until it reaches `n`, something I was unaware of.

Specifically, to quote [R..][2]

&gt; strncpy does not null-terminate, and
&gt; does null-pad the whole remainder of
&gt; the destination buffer, which is a
&gt; huge waste of time. You can work
&gt; around the former by adding your own
&gt; null padding, but not the latter. It
&gt; was never intended for use as a &quot;safe
&gt; string handling&quot; function, but for
&gt; working with fixed-size fields in Unix
&gt; directory tables and database files.
&gt; snprintf(dest, n, &quot;%s&quot;, src) is the
&gt; only correct &quot;safe strcpy&quot; in standard
&gt; C, but it&#39;s likely to be a lot slower.
&gt; By the way, truncation in itself can
&gt; be a major bug and in some cases might
&gt; lead to privilege elevation or DoS, so
&gt; throwing &quot;safe&quot; string functions that
&gt; truncate their output at a problem is
&gt; not a way to make it &quot;safe&quot; or
&gt; &quot;secure&quot;. Instead, you should ensure
&gt; that the destination buffer is the
&gt; right size and simply use strcpy (or
&gt; better yet, memcpy if you already know
&gt; the source string length).

And from [Jonathan Leffler][3]

&gt; Note that strncat() is even more
&gt; confusing in its interface than
&gt; strncpy() - what exactly is that
&gt; length argument, again? It isn&#39;t what
&gt; you&#39;d expect based on what you supply
&gt; strncpy() etc - so it is more error
&gt; prone even than strncpy(). For copying
&gt; strings around, I&#39;m increasingly of
&gt; the opinion that there is a strong
&gt; argument that you only need memmove()
&gt; because you always know all the sizes
&gt; ahead of time and make sure there&#39;s
&gt; enough space ahead of time. Use
&gt; memmove() in preference to any of
&gt; strcpy(), strcat(), strncpy(),
&gt; strncat(), memcpy().

So, I&#39;m clearly a little rusty on the C standard library. Therefore, I&#39;d like to pose the question:

**What C standard library functions are used inappropriately/in ways that may cause/lead to security problems/code defects/inefficiencies?**

In the interests of objectivity, I have a number of criteria for an answer:

 - Please, if you can, cite design reasons behind the function in question i.e. its intended purpose.
 - Please highlight the misuse to which the code is currently put.
 - Please state why that misuse may lead towards a problem. I know that should be obvious but it prevents soft answers.

Please avoid:

 - Debates over naming conventions of functions (except where this unequivocably causes confusion).
 - &quot;I prefer x over y&quot; - preference is ok, we all have them but I&#39;m interested in actual unexpected side effects and how to guard against them.

As this is likely to be considered subjective and has no definite answer I&#39;m flagging for community wiki straight away.

I am also working as per C99.

  [1]: https://stackoverflow.com/questions/4580329/string-handling-practices-in-c
  [2]: https://stackoverflow.com/users/379897/r
  [3]: https://stackoverflow.com/users/15168/jonathan-leffler

Which functions in the C standard library commonly encourage bad practice?

I am teaching a graduate level Python class at the University of Paris, and the students need to be introduced to the standard library.  I want to discuss with them about some of the most important standard modules.

What modules do you think are absolute musts?  Even though responses probably vary depending on your field (web programming, science, etc.), I feel that some modules are commonly needed: `math`, `sys`, `re`, `os`, `os.path`, `logging`,… and maybe: `collections`, `struct`,…

What modules would you suggest I present, in a 1 or 2 hour slot?

Most useful Python modules from the standard library?

I am trying to achieve the functionality similar to unlist, with the exception that types are not coerced to a vector, but the list with preserved types is returned instead. For instance:

    flatten(list(NA, list(&quot;TRUE&quot;, list(FALSE), 0L))

should return

    list(NA, &quot;TRUE&quot;, FALSE, 0L)
instead of

    c(NA, &quot;TRUE&quot;, &quot;FALSE&quot;, &quot;0&quot;)
which would be returned by `unlist(list(list(NA, list(&quot;TRUE&quot;, list(FALSE), 0L))`.

As it is seen from the example above, the flattening should be recursive. Is there a function in standard R library which achieves this, or at least some other function which can be used to easily and efficiently implement this?

**UPDATE**: I don&#39;t know if it is clear from the above, but non-lists should not be flattened, i.e. `flatten(list(1:3, list(4, 5)))` should return `list(c(1, 2, 3), 4, 5)`.

How to flatten a list to a list without coercion?

EDIT: I have asked an opposing question here: https://stackoverflow.com/questions/34724879/how-to-embed-python3-with-the-standard-library

A solution for Python2 is provided here: https://stackoverflow.com/questions/20951624/is-it-possible-to-embed-python-without-the-standard-library

However, Python3 fails on `Py_Initialize();` with:

    Fatal Python error: Py_Initialize: unable to load the file system  
    codec ImportError: No module named &#39;encodings&#39;

This makes sense because py3 source files are utf-8 by default. So it seems that it requires an external binary just in order to parse py3 source files.

So what to do?

It looks as though I need to locate the `encodings` binary in my system Python installation, copy this into my project tree, and maybe set some environment variable PYTHONPATH(?) So that my libpython.dylib can find it.

Is it possible to avoid this? And if not, can anyone clarify the steps I need to take? Are there going to be any more hiccups?

----------

NOTE: For posterity, this is how I got a stand-alone libpython.dylib linking into my project on OSX:

First I locate my system Python&#39;s library: `/usr/local/Frameworks/Python.framework/Versions/3.4/Python` (in my case it was installed with homebrew).

Now I:

 - copy the .dylib into my project folder creating `./Libs/libpython3.4.1_OSX.dylib`

 - Go into `build settings -&gt; linking` and set `other linker flags` to `-lpython3.4.1_OSX`  

At this point it will appear to work. However if you know try building it on a fresh OSX installation, it will fail. This is because:

    $ otool -D ./libpython3.4.1_OSX.dylib 
    ./libpython3.4.1_OSX.dylib:
    /usr/local/Frameworks/Python.framework/Versions/3.4/Python

The .dylib is still holding onto it&#39;s old location.  It&#39;s really weird to me that the .dylib contains a link to its location, as anything that uses it must know where it is in order to invoke it in the first place!

We can correct this with:

    $ install_name_tool -id @rpath/libpython3.4.1_OSX.dylib libpython3.4.1_OSX.dylib

But then also in our Xcode project we must:

* Go into `build phases`. Add a `copy files` step that copies `libpython3.4.1_OSX.dylib` to `Frameworks` (that&#39;s the right place to put it).  
* Go into `build settings -&gt; linking` and set `runpath search paths` to `@executable_path/../Frameworks/libpython3.4.1_OSX.dylib`  

Finally I need to go into `edit scheme -&gt; run -&gt; arguments -&gt; environment variables` and add `PYTHONHOME` with value `../Frameworks`

I suspect that to get this working I will also need to add a `PYTHONPATH`

Links:  
https://mikeash.com/pyblog/friday-qa-2009-11-06-linking-and-install-names.html  
http://qin.laya.com/tech_coding_help/dylib_linking.html  
https://github.com/conda/conda-build/issues/279#issuecomment-67241554  
https://stackoverflow.com/questions/9263256/can-you-please-help-me-understand-how-mach-o-libraries-work-in-mac-os-x  
http://nshipster.com/launch-arguments-and-environment-variables/  

Embed Python3 without standard library

What does the &quot;c&quot; mean in the `cout`, `cin`, `cerr` and `clog` names?

I would say `char` but I haven&#39;t found anything to confirm it.

What does the &quot;c&quot; mean in cout, cin, cerr and clog?

What are the reasons for the existence of [`std::decay`][1]?
In what situations is [`std::decay`][2] useful?


  [1]: http://en.cppreference.com/w/cpp/types/decay
  [2]: http://en.cppreference.com/w/cpp/types/decay

What is std::decay and when it should be used?

I need to read a whole file into memory and place it in a C++ `std::string`.

If I were to read it into a `char[]`, the answer would be very simple:

    std::ifstream t;
    int length;
    t.open(&quot;file.txt&quot;);      // open input file
    t.seekg(0, std::ios::end);    // go to the end
    length = t.tellg();           // report location (this is the length)
    t.seekg(0, std::ios::beg);    // go back to the beginning
    buffer = new char[length];    // allocate memory for a buffer of appropriate dimension
    t.read(buffer, length);       // read the whole file into the buffer
    t.close();                    // close file handle
    
    // ... Do stuff with buffer here ...

Now, I want to do the exact same thing, but using a `std::string` instead of a `char[]`. I want to avoid loops, i.e. I **don&#39;t** want to:

    std::ifstream t;
    t.open(&quot;file.txt&quot;);
    std::string buffer;
    std::string line;
    while(t){
    std::getline(t, line);
    // ... Append line to buffer and go on
    }
    t.close()

Any ideas?

Read whole ASCII file into C++ std::string

I feel like I must just be unable to find it. Is there any reason that the C++ `pow` function does not implement the &quot;power&quot; function for anything except `float`s and `double`s?

I know the implementation is trivial, I just feel like I&#39;m doing work that should be in a standard library. A robust power function (i.e. handles overflow in some consistent, explicit way) is not fun to write.

Why isn&#39;t `int pow(int base, int exponent)` in the standard C++ libraries?

Looking for a better way to get a machines current external IP #... Below works, but would rather not rely on an outside site to gather the information ... I am restricted to using standard Python 2.5.1 libraries bundled with Mac OS X 10.5.x

    import os
    import urllib2

    def check_in():

        fqn = os.uname()[1]
        ext_ip = urllib2.urlopen(&#39;http://whatismyip.org&#39;).read()
        print (&quot;Asset: %s &quot; % fqn, &quot;Checking in from IP#: %s &quot; % ext_ip)

Getting a machine&#39;s external IP address with Python

Go&#39;s standard library does not have a function solely intended to check if a file exists or not (like Python&#39;s [`os.path.exists`][1]). What is the **idiomatic** way to do it?


  [1]: http://docs.python.org/library/os.path.html#os.path.exists

How to check if a file exists in Go?

Please consider this code. I have seen this type of code several times. `words` is a local vector. How is it possible to return it from a function?

Can we guarantee it will not die?

     std::vector&lt;std::string&gt; read_file(const std::string&amp; path)
     {
        std::ifstream file(&quot;E:\\names.txt&quot;);

        if (!file.is_open())
        {
            std::cerr &lt;&lt; &quot;Unable to open file&quot; &lt;&lt; &quot;\n&quot;;
            std::exit(-1);
        }

        std::vector&lt;string&gt; words;//this vector will be returned
        std::string token;

        while (std::getline(file, token, &#39;,&#39;))
        {
            words.push_back(token);
        }

        return words;
    }



Why is it OK to return a &#39;vector&#39; from a function?

I set up CDT for eclipse and wrote a simple hello world C program:

    #include &lt;stdio.h&gt;
    
    int main(void){
        puts(&quot;Hello, world.&quot;);
    	return 0;
    }

The program builds and runs correctly, but eclipse keeps showing this yellow question mark by the side of inclusion statement that says `&quot;Unresolved inclusion: &lt;stdio.h&gt;&quot;` when I put mouse over it.

It doesn&#39;t affect running of the program but I find it rather annoying.

Does anyone have any idea how to remove it?

&quot;Unresolved inclusion&quot; error with Eclipse CDT for C standard library headers

Is there a module for an [AVL tree](https://en.wikipedia.org/wiki/AVL_tree) or a [red–black tree](https://en.wikipedia.org/wiki/Red%E2%80%93black_tree) or some other type of a balanced binary tree in the standard library of Python?
 

Is there a module for balanced binary tree in Python&#39;s standard library?

I&#39;ve read on Stack Overflow that some C functions are &quot;obsolete&quot; or &quot;should be avoided&quot;. Can you please give me some examples of this kind of function and the reason why?

What alternatives to those functions exist?

Can we use them safely - any good practices?


Which functions from the standard library must (should) be avoided?

Consider a function of the following general form:

    Foo findFoo(Collection&lt;Foo&gt; foos, otherarguments)
    throws ObjectNotFoundException {
        for(Foo foo : foos){
            if(/* foo meets some condition*/){
                return foo;
            }
        }
        throw new ObjectNotFoundException();
    }
     
A concrete case, for example, would be:
    
    User findUserByName(Collection&lt;User&gt; users, String name)
    throws ObjectNotFoundException {
        for(User user : users){
            if(user.getName().equals(name)){
                return user;
            }
        }
        throw new ObjectNotFoundException();
    }

These functions throw an exception if the object is not found. I can create a custom exception class for this purpose (in the examples, `ObjectNotFoundException`) but I would prefer to use an existing class. However, I could not find any exception class with this meaning in the standard java library. Do you know if there is a standard exception that can be used here?

Is there a standard java exception class that means &quot;The object was not found&quot;?

I have two postcodes `char*` that I want to compare, ignoring case.
Is there a function to do this?

Or do I have to loop through each use the `tolower` function and then do the comparison?

Any idea how this function will react with numbers in the string

Thanks

Case Insensitive String Comparison in C

I&#39;m fairly familiar with C++11&#39;s `std::thread`, `std::async` and `std::future` components (e.g. see [this answer](https://stackoverflow.com/a/10998831/596781)), which are straight-forward.

However, I cannot quite grasp what `std::promise` is, what it does and in which situations it is best used. The standard document itself doesn&#39;t contain a whole lot of information beyond its class synopsis, and neither does [std::thread](http://www.stdthread.co.uk/doc/headers/future/promise.html).

Could someone please give a brief, succinct example of a situation where an `std::promise` is needed and where it is the most idiomatic solution?

What is std::promise?

I know it is a common issue, but looking for references and other material I don&#39;t find a clear answer to this question.

Consider the following code:

    #include &lt;string&gt;
    
    // ...
    // in a method
    std::string a = &quot;Hello &quot;;
    std::string b = &quot;World&quot;;
    std::string c = a + b;

The compiler tells me it cannot find an overloaded operator for `char[dim]`.

Does it mean that in the string there is not a + operator?

But in several examples there is a situation like this one. If this is not the correct way to concat more strings, what is the best way?

Concatenating strings doesn&#39;t work as expected

I&#39;m a little confused by &quot;C standard lib&quot; and &quot;C POSIX lib&quot;, because I found that, many header files defined in &quot;C POSIX lib&quot; are also part of &quot;C standard lib&quot;. 

So, I assume that, &quot;C standard lib&quot; is a lib defined by ANSI C organization, and there are different implementation on different platforms (Win32/Unix-like), and &quot;C POSIX lib&quot; is just a implementation for &quot;C standard lib&quot; on Unix-like OSes, right?

But &quot;C POSIX lib&quot; contains some headers not specified in &quot;C standard lib&quot;, such as `&lt;sys/types.h&gt;`, `&lt;sys/wait.h&gt;`, and `&lt;pthread.h&gt;`.

Take `&lt;pthread.h&gt;` as an example, I presume its &quot;C standard lib&quot; counterpart is `&lt;threads.h&gt;`, then if I want to write a multi-threaded program on Linux, which header file should I include, `&lt;pthread.h&gt;` or `&lt;threads.h&gt;`?

Difference between C standard library and C POSIX library

A textbook I have notes that you can provide your own implementation for standard library functions like `swap(x,y)` via template specialization or function overloading.  This would be useful for any types which can benefit from something other than an assignment swap, like STL containers for example (which already have swaps written, I know).

**My questions are the following:**

 1. What&#39;s better: template specialization to give your specialized
swap implementation, or function overloading providing the exact
parameters you wish to use without a template?

 2. Why is it better? Or if they&#39;re equal, why is this?

Template Specialization VS Function Overloading

I found out about Python&#39;s ord() function which returns corresponding Unicode codepoint value. But what is the opposite function, i.e. get char value by int?

Edit: I&#39;m new to SO, and couldn&#39;t find the answer here, so decided to post in order to everyone could find it more easily, although the answer is quite obvious. Then I read this - https://meta.stackoverflow.com/questions/261592/how-much-research-effort-is-expected-of-stack-overflow-users and realised it was a huge mistake. Apologies. hope it **will** be useful in that sense.

What is the opposite of python&#39;s ord() function?

I was searching for the source code of the C standard libraries. What I mean with it is, for example, how are cos, abs, printf, scanf, fopen, and all the other standard C functions written, I mean to see their source code.

So while searching for this, I came across with GLIBC, but I don&#39;t know what it actually is. It is GNU C Library, and it contains some source codes, but what are they actually, are they the source code of the standard functions or are they something else? And what is it used for?

What is GLIBC? What is it used for?

Given this C++11 program, should I expect to see a number or a letter?  Or not make expectations?

    #include &lt;cstdint&gt;
    #include &lt;iostream&gt;
    
    int main()
    {
        int8_t i = 65;
        std::cout &lt;&lt; i;
    }

Does the standard specify whether this type can or will be a character type?

Are int8_t and uint8_t intended to be char types?

I might have an array that looks like the following:

&lt;pre&gt;&lt;code&gt;[1, 4, &lt;b&gt;2&lt;/b&gt;, &lt;b&gt;2&lt;/b&gt;, &lt;b&gt;6&lt;/b&gt;, 24, &lt;b&gt;15&lt;/b&gt;, 2, 60, &lt;b&gt;15&lt;/b&gt;, &lt;b&gt;6&lt;/b&gt;]&lt;/pre&gt;&lt;/code&gt;

Or, really, any sequence of like-typed portions of data. What I want to do is ensure that there is only one of each identical element. For example, the above array would become:

&lt;pre&gt;&lt;code&gt;[1, 4, &lt;b&gt;2&lt;/b&gt;, &lt;b&gt;6&lt;/b&gt;, 24, &lt;b&gt;15&lt;/b&gt;, 60]&lt;/pre&gt;&lt;/code&gt;

Notice that the duplicates of 2, 6, and 15 were removed to ensure that there was only one of each identical element. Does Swift provide a way to do this easily, or will I have to do it myself?


Removing duplicate elements from an array in Swift

I wanted to see how a `math.py` function was implemented, but when I opened the file in PyCharm I found that all the functions are empty and there is a simple `pass`. For example:

    def ceil(x): # real signature unknown; restored from __doc__
        &quot;&quot;&quot;
        ceil(x)
    
        Return the ceiling of x as a float.
        This is the smallest integral value &gt;= x.
        &quot;&quot;&quot;
        pass

I guess it is because the functions being used are actually from the C standard library. How does it work? 

Why do some built-in Python functions only have pass?

How can I check if a Perl module is part of the core - i.e. it is part of the standard installation?

I&#39;m looking for:

  - a command-line command:
  - a Perl subroutine/function to check within code

Perhaps the question should be: How can I tell what modules were originally provided with the *specific* Perl installation on a machine? (Actually, it is now asked as *https://stackoverflow.com/questions/2085516/how-can-i-tell-what-modules-were-originally-provided-with-the-specific-perl-insta*.)

Given that there now appears to not to be an overall Perl standard installation, at least the answer to this new question will tell me what I originally had in the installation when it was first installed.

With that knowledge and if I keep the original installer image/package OR know how to get the exact thing again online, then I have a repeatable Perl installation for several machines with the knowledge of what modules will be present and what modules will not. 

To clarify further: I am looking at what *came* with the installation originally, what modules were provided as part of that installation, and what was built-in. *NOT* what has been installed since then.

And I want to be able to do this *on the machine that has the installation*. So for this I would be relying upon the installation to have a record in some form as to what it has originally.

I asked spin-off question:
*https://stackoverflow.com/questions/2085516/how-can-i-tell-what-modules-were-originally-provided-with-the-specific-perl-insta* (How can I tell what modules were originally provided with the specific Perl installation on a machine?)



How can I tell if a Perl module is core or part of the standard install?

**Consider the Object-Oriented Languages:**

Most people coming from an object-oriented programming background, are familiar with the common and intuitive interfaces in various languages that capture the essence of Java&#39;s [**`Collection`**][1] &amp; [**`List`**][2] interfaces. **`Collection`** refers to a  collection of objects which doesn&#39;t necessarily have an natural ordering/indexing. A **`List`** is a collection which has a natural ordering/indexing. These interfaces abstract many library data-structures in Java, as do their equivalent interfaces in other languages, and an intimate understanding of these interfaces are required to work effectively with most library data-structures.

**Transition to Haskell:**

Haskell has a type-class system which acts on types analogously to interfaces on objects. Haskell seems to have a [well designed type-class hierarchy][3] with regard to Functors, Applicative, Monads, etc. when the type regard functionality. They obviously want [correct and well-abstracted type-classes][4]. Yet when you look at many Haskell&#39;s containers ([**`List`**][5],[**`Map`**][6],[**`Sequence`**][7],[**`Set`**][8],[**`Vector`**][9]) they almost all have very similar (or identical) functions, yet aren&#39;t abstracted through type-classes.

**Some Examples:**

 * `null` for testing &quot;emptyness&quot;
 * `length`**/**`size` for element count
 * `elem`**/**`member` for set inclusion
 * `empty` *and/or* `singleton` for default construction
 * `union` for set union
 * `(\\)`**/**`diff` for set difference
 * `(!)`**/**`(!!)` for unsafe indexing (partial function)
 * `(!?)`**/**`lookup` for safe indexing (total function)

If I want to use any of the functions above, but I have imported two or more containers I have to start hiding functions from the imported modules, or explicitly import only the necessary functions from the modules, or qualifying the imported modules. But since all the functions provide the same logical functionality, it just seems like a hassle. If the functions were defined from type-classes, and not separately in each module, the compiler&#39;s type inference mechanics could resolve this. It would also make switching underlying containers simple as long as they shared the type-classes (ie: lets just use a `Sequence` instead of `List` for better random access efficiency).

Why doesn&#39;t Haskell have a **`Collection`** and/or **`Indexable`** type-class(es) to unify &amp; generalize some of these functions?



  [1]: http://docs.oracle.com/javase/7/docs/api/java/util/Collections.html
  [2]: http://docs.oracle.com/javase/7/docs/api/java/util/List.html
  [3]: http://www.haskell.org/wikiupload/d/df/Typeclassopedia-diagram.png
  [4]: http://www.haskell.org/haskellwiki/Functor-Applicative-Monad_Proposal
  [5]: http://hackage.haskell.org/package/base-4.7.0.1/docs/Data-List.html
  [6]: http://hackage.haskell.org/package/containers-0.2.0.1/docs/Data-Map.html
  [7]: http://hackage.haskell.org/package/containers-0.5.5.1/docs/Data-Sequence.html
  [8]: http://www.haskell.org/ghc/docs/latest/html/libraries/containers-0.5.5.1/Data-Set.html
  [9]: https://hackage.haskell.org/package/vector-0.9.1/docs/Data-Vector.html

All Standard Library Solutions on Gang of Coders

Total of 28 Standard Library Solutions

Subclass/inherit standard containers?

Which functions in the C standard library commonly encourage bad practice?

Most useful Python modules from the standard library?

How to flatten a list to a list without coercion?

Embed Python3 without standard library

What does the "c" mean in cout, cin, cerr and clog?

What is std::decay and when it should be used?

Read whole ASCII file into C++ std::string

Why isn't `int pow(int base, int exponent)` in the standard C++ libraries?

Getting a machine's external IP address with Python

How to check if a file exists in Go?

Why is it OK to return a 'vector' from a function?

"Unresolved inclusion" error with Eclipse CDT for C standard library headers

Is there a module for balanced binary tree in Python's standard library?