standard-library

What's the best way to read a file backwards in C? I know at first you may be thinking that this is no use whatsoever, but most logs etc. append the most recent data at the end of the file. I want to read in text from the file backwards, buffering it into lines - that is abc def ghi should read ghi , def , abc in lines. So far I have tried: #include <stdio.h> #include <stdlib.h> void read_file(FILE *fileptr) { char currentchar = '\0'; int size = 0; while( currentchar != '\n' ) { currentchar = fgetc(fileptr); printf("%c\n", currentchar); fseek(fileptr, -2, SEEK_CUR); if( currentchar == '\n') {

Is there a module for AVL or Red-Black or some other type of a balanced binary tree in the standard library of Python? I have tried to find one, but unsuccessfully (I'm relatively new to Python). No, there is not a balanced binary tree in the stdlib. However, from your comments, it sounds like you may have some other options: You say that you want a BST instead of a list for O(log n) searches. If searching is all you need and your data are already sorted, the bisect module provides a binary search algorithm for lists. Mike DeSimone recommended sets and dicts and you explained why lists are too

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<std::string> read_file(const std::string& path) { std::ifstream file("E:\\names.txt"); if (!file.is_open()) { std::cerr << "Unable to open file" << "\n"; std::exit(-1); } std::vector<string> words;//this vector will be returned std::string token; while (std::getline(file, token, ',')) { words.push_back(token); } return words; } Can we guarantee it will not die? As long there is no reference returned, it's

I'm fairly familiar with C++11's std::thread , std::async and std::future components (e.g. see this answer ), 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't contain a whole lot of information beyond its class synopsis, and neither does just::thread . 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? Jonathan Wakely In the words of [futures.state] a std::future is an asynchronous

How can a standard-library module (say math) be accessed when a file prog.py is placed in the same directory as a local module with the same name (math.py)? I'm asking this question because I would like to create a package uncertainties that one can use as import uncertainties from uncertainties.math import * Thus, there is a local math module inside the uncertainties directory. The problem is that I want to access the standard library math module from uncertainties/__init__.py. I prefer not to rename uncertainties.math because this module is precisely intended to replace functions from the

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("TRUE", list(FALSE), 0L)) should return list(NA, "TRUE", FALSE, 0L) instead of c(NA, "TRUE", "FALSE", "0") which would be returned by unlist(list(list(NA, list("TRUE", 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

I've read on Stack Overflow that some C functions are "obsolete" or "should be avoided". 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? Deprecated Functions Insecure A perfect example of such a function is gets() , because there is no way to tell it how big the destination buffer is. Consequently, any program that reads input using gets() has a buffer overflow vulnerability . For similar reasons, one should use strncpy() in place of strcpy() and strncat() in place of