Wednesday, September 17, 2014

Digest for comp.lang.c++@googlegroups.com - 25 updates in 6 topics

comp.lang.c++@googlegroups.com Google Groups
Unsure why you received this message? You previously subscribed to digests from this group, but we haven't been sending them for a while. We fixed that, but if you don't want to get these messages, send an email to comp.lang.c+++unsubscribe@googlegroups.com.
ram@zedat.fu-berlin.de (Stefan Ram): Sep 12 09:42PM

>"Now, here, you see, it takes all the running you can do, to keep in
>the same place. If you want to get somewhere else, you must run at
>least twice as fast as that!" -- The Red Queen
 
In fact, it suffices to run just ever so slightly
faster than that. »That« is called the »break-even
point«. (Sorry for replying to a signature, I could
not resist.)
ram@zedat.fu-berlin.de (Stefan Ram): Sep 11 11:58AM

>I can think of a number of ways to do this, but I don't like any of
>them. What do you think is the most elegant way to do this?
 
The constructor+iterator combination is elegant, but the fastest
way is to get the filesize and then pre-allocate a buffer.
 
Getting the filesize is difficult. First, one must take into
account that it might change between obtaining the filesize and
reading (think of a log file). Then, one can't just seek to the EOF:
 
»seekg« and »tellg« seem to be defined using »pubseekoff« in
ISO/IEC 14882:1998(E), which is defined in terms of »seekoff«,
which is defined based on »::std::fseek«. ISO/IEC 9899:1990
explains about »::std::fseek«:
 
»A binary stream need not meaningfully support
fseek calls with a whence value of SEEK_END.«
 
»::std::ate« requests a seek to the end of the file.
 
Therefore, one can not assume that one will be able to obtain
the size of a binary file in this way under every
implementation of C++. One needs to look up the documentation
of the implementation to find out whether it supports fseek
calls with a whence value of SEEK_END in binary files.
 
BTW: Has anyone actually ever seen such a document of an
implementation where it specifies (all) the implementation-
specified assertions? Where, for example, can one find this
for gcc in the case of C++?
 
A reasonable compromise might be copying the file to a string
stream and then converting that string stream to a string.
ram@zedat.fu-berlin.de (Stefan Ram): Sep 10 11:32PM

>Are there any IDEs (if you exclude emacs) that don't require a windowing
>system?
 
The Unix command line is the ultimate IDE IMHO.
You get: man pages, ctags, valgrind, ... you name it.
 
Then, SCNR, we also got vim, which has, IIRC, several
customizations (kind of macro packages) for development
purposes.
 
There is a vim IDE to develop Android programs on Android
itself (native). I'm not aware of any other IDE, be it with
or without a windowing system, that runs on Android and
allows one to develope Android software in C++ and in Java.
Luca Risolia <luca.risolia@linux-projects.org>: Sep 11 07:18PM +0200

glen stark wrote:
 
 
> I can think of a number of ways to do this, but I don't like any of
> them. What do you think is the most elegant way to do this?
 
> Thanks,
 
Try this:
 
http://www.linux-projects.org/listing/cpp_solutions/20.5/main.cpp
 
Below is the code:
 
#include <string>
#include <iterator>
#include <iostream>
#include <algorithm>
#include <vector>
 
namespace mystd {
 
template<class Cont> class back_insert_iterator;
 
/*
* Base class for all the back_insert_iterator's. It requires
* a back_insert_iterator class as template argument.
*/
template<class Cont, class Derived = back_insert_iterator<Cont> >
class back_insert_iterator_base : public
std::iterator<std::output_iterator_tag, void, void, void, void> {
protected:
Cont& container;
 
explicit back_insert_iterator_base(Cont& c) : container(c) { }
 
public:
typedef Cont container_type;
 
Derived& operator=(typename container_type::const_reference v) {
container.push_back(v);
return *(static_cast<Derived*> (this));
}
 
Derived& operator++() {
return *(static_cast<Derived*> (this));
}
 
Derived& operator++(int) {
return *(static_cast<Derived*> (this));
}
 
Derived& operator*() {
return *(static_cast<Derived*> (this));
}
};
 
/*
* Generic back_insert_iterator for any container
*/
template<class Cont>
class back_insert_iterator : public back_insert_iterator_base<Cont> {
public:
 
explicit back_insert_iterator(Cont& c) :
back_insert_iterator_base<Cont> (c) { }
using back_insert_iterator_base<Cont>::operator =;
};
 
/*
* Specialized class for a basic_string's:
* this class adds one more operator=() implementing string concatenation
*/
template<class Ch, class Tr, class A>
class back_insert_iterator<std::basic_string<Ch, Tr, A> > : public
back_insert_iterator_base<std::basic_string<Ch, Tr, A> > {
public:
 
explicit back_insert_iterator(std::basic_string<Ch, Tr, A>& c) :
back_insert_iterator_base<std::basic_string<Ch, Tr, A> > (c) { }
using back_insert_iterator_base<std::basic_string<Ch, Tr, A>
>::operator =;
 
back_insert_iterator& operator=(const std::basic_string<Ch, Tr, A> &
s) {
back_insert_iterator_base<std::basic_string<Ch, Tr, A>
>::container.append(s);
return *this;
}
};
 
/*
* This is convenience function. It returns a back insert iterator
* for a container without requiring us to specify any template argument.
*/
template <class Cont> back_insert_iterator<Cont> back_inserter(Cont& c) {
return back_insert_iterator<Cont > (c);
}
}
 
int main(int argc, char** argv) {
// Two examples
using namespace std;
typedef basic_string<char> String;
vector<String > v;
copy(std::istream_iterator<String > (std::cin),
std::istream_iterator<String > (), mystd::back_inserter(v));
String s;
copy(v.begin(), v.end(), mystd::back_inserter(s));
cout << s;
return 0;
}
glen stark <g.a.stark@gmail.com>: Sep 10 10:41AM

Hi everyone.
 
I'm in the position that I have an input stream, start_pos, and end_pos,
and I'd like to copy the contents of the stream from start_pos to end_pos
into a string.
 
I can think of a number of ways to do this, but I don't like any of
them. What do you think is the most elegant way to do this?
 
Thanks,
Victor Bazarov <v.bazarov@comcast.invalid>: Sep 11 08:50AM -0400

On 9/11/2014 7:58 AM, Stefan Ram wrote:
 
> The constructor+iterator combination is elegant, but the fastest
> way is to get the filesize and then pre-allocate a buffer.
 
> Getting the filesize is difficult. [..]
 
Who said it was a file?
 
V
--
I do not respond to top-posted replies, please don't ask
Juha Nieminen <nospam@thanks.invalid>: Sep 10 02:24PM

> into a string.
 
> I can think of a number of ways to do this, but I don't like any of
> them. What do you think is the most elegant way to do this?
 
std::copy with a std::back_inserter.
 
It might not be the most *efficient* implementation, but it's fairly
short, simple and elegant.
 
--- news://freenews.netfront.net/ - complaints: news@netfront.net ---
Victor Bazarov <v.bazarov@comcast.invalid>: Sep 10 08:33AM -0400

On 9/10/2014 6:41 AM, glen stark wrote:
> into a string.
 
> I can think of a number of ways to do this, but I don't like any of
> them. What do you think is the most elegant way to do this?
 
It must be by means of std::copy.
 
V
--
I do not respond to top-posted replies, please don't ask
"Rick C. Hodgin" <rick.c.hodgin@gmail.com>: Sep 17 04:00PM -0700

On Tuesday, September 16, 2014 3:38:32 AM UTC-4, David Brown wrote:
> standards folk, the usual reasoning is that C++ constructors provide a
> better system than C's designated initialisers, and thus you should use
> constructors.
 
Compilers are tools. My thinking is this: I should not have to manually
do something the compiler can do for me. :-) When there is no ambiguity
in the initialization type, for example, the compiler should be able to
receive whatever I pass to it, and assemble it for me, at compile time
so I don't have to execute any code at runtime, nor perform the manual
steps of writing code which is executed at runtime.
 
struct SExample
{
union {
int i;
float f;
};
};
 
SExample myArray[] = {
{ 10 }, // Initialized into i
{ 29.7f } // Initialized into f
};
 
If there is any ambiguity about the type, then it could fall back to a
top-down method where it maps into the first one which is close, or
would use an algorithm, such as only directly mapping if the two or
twelve conflicting types available actually occupy the same memory space
within the union (because in such a case it really doesn't matter which
one it maps to because they all map to the same place in memory).
 
That also brings up another need as I see it... the ability to
explicitly indicate where a union should fall at compile time, and
without having to pad it manually.
 
struct SExample2
{
union {
double d;
char c;
};
};
 
I should be able to place these wherever I want them. In fact, for some
low-level purposes this would be desirable.
 
struct SExample2
{
union {
double d (|4,#,8|);
char c (|top|);
};
};
 
Something here like:
(|4,#,8|) indicates 4 bytes padding before, the # of bytes for the thing,
and then 8 bytes padding after. So in this case d would be initialized
to consume 20 bytes, with 4 bytes padding before the variable in memory,
then the 8 bytes d occupies, and then 8 bytes of padding after.
 
(|top|) would indicate that c should go to the top of the memory block
(to the greatest/highest memory address based on the other union members).
 
The storage for such a union would then be (in bytes):
d: [pad1 4:0,0,0,0][d 8:0,0,0,0,0,0,0,0][pad2 8:0,0,0,0,0,0,0,0]
c: [c 1:0][pad 19:0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
 
In addition, I should be able to manually indicate where I want something
to go to complete override its basic type, such as using an initializer
with a cask after, as in:
 
SExample myArray[] = {
{ 10 (|#,2,3|) }, // Initialized as 16-bits at offset 3
{ 29.7f } // Initialized into f
};
 
This would have the effect of increasing the sizeof(SExample) to 5
bytes because the position of the example here would run to offsets
3..4, which are bytes 4 and 5.
 
> used for compile-time initialisation (perhaps they can now with
> "constexpr"?), and are incompatible with C. Each method has its
> advantages and disadvantages, and people want both.
 
I don't think anyone would suggest taking away constructors. :-)
They have their place for sure. But, right now, compile time
initialization to non-topmost union members is impossible without
reaching into a compiler extension like gcc's name designation.
That hindrance is unnecessary, and hampers the use of unions, a
perfectly valid tool in the developer's arsenal.
 
> difference - designated initialisers is, IMHO, the most important. And
> since gcc is quite happy with designated initialisers in C++, it seems
> there would be no problem adding it to the language.
 
Designated initializers should only be needed in special cases. But I
agree they should be available.
 
> and ambiguous, especially once classes with constructors got involved.
> Designated initialisers are conceptually simpler, more explicit, and
> more flexible.
 
The compiler could set limits on things to keep them simple. If it is not
something that can be explicitly resolved at compile time using only basic
translation, then it is required to perform the operation at runtime.
 
However, even in such a case the compiler could still identify that it
is of such a kind and automatically generate the code so that it is
performed at runtime, even though it appears as though it was done
at compile time. The only issue there would be object code which contains
incomplete data as it has not yet initialized itself as one might
otherwise expect it should be given that the initialization was
performed by the developer at compile time.
 
I think that's a minor issue though. And I can't imagine a case where
initialization into a union member is so complex that it cannot be
resolved at compile time, or it can't have the code to automatically
populate into the appropriate location be automatically inserted and
performed at runtime.
 
Can you think of such an example?
 
Best regards,
Rick C. Hodgin
Stuart <DerTopper@web.de>: Sep 11 02:30PM +0200

On 09/11/14, Ian Collins wrote:
[snip]
> Are there any IDEs (if you exclude emacs) that don't require a windowing
> system?
 
I once read the following comment, but I cannot find the original source
(http://c2.com/cgi/wiki?EmacsAsOperatingSystem comes close, but it was a
different site).
 
<<Emacs is not a text editor. It has so many features that the closest
you can call it is an operating system. Sadly, it is not a "real" OS
because it lacks a simple and usable text editor ... >>
 
SCNR,
Stuart
Jorgen Grahn <grahn+nntp@snipabacken.se>: Sep 12 06:13AM

On Thu, 2014-09-11, SG wrote:
> be as convenient (or even more convenient) as popular IDEs. But it
> probably takes more time to learn compared to a single, well-
> integrated application.
 
I feel the same way about "proper" IDEs like Eclipse (or whatever it's
called when it's used for C++ programming).
 
I've used Unix for all of my work (programming in different languages,
and anything else that requires a computer) since 1996 or so. You
can't help learning the tools over the years (although you will almost
certainly miss some of them).
 
> But maybe it's just me not having come across a nice article
> explaining how to setup editor X, compiler Y, debugger Z and
> accompanioning tools/plugins for language L.
 
You normally don't have to invest in that many new tools for a new
language. Same editor, same build system, same version control.
 
True, teaching people to use Unix could be done much better (unless
there are good books that I'm unaware of).
 
/Jorgen
 
--
// Jorgen Grahn <grahn@ Oo o. . .
\X/ snipabacken.se> O o .
Koneko <Koneko@idontwantspamfrom.net>: Sep 11 05:27PM +0300

Ian Collins wrote:
> Are there any IDEs (if you exclude emacs) that don't require a windowing
> system?
 
♪ Vim! Vim! Vim! Is a win for you. ♪♪
 
Install Vundle and go crazy. lol
 
https://github.com/gmarik/Vundle.vim
 
 
--
Koneko
Jorgen Grahn <grahn+nntp@snipabacken.se>: Sep 11 11:50AM

On Wed, 2014-09-10, Stefan Ram wrote:
>>system?
 
> The Unix command line is the ultimate IDE IMHO.
> You get: man pages, ctags, valgrind, ... you name it.
 
And it's easily extendable and programmable ...
 
/Jorgen
 
--
// Jorgen Grahn <grahn@ Oo o. . .
\X/ snipabacken.se> O o .
Ian Collins <ian-news@hotmail.com>: Sep 11 10:46AM +1200

Lynn McGuire wrote:
> http://cpprocks.com/jetbrains-clion-c-ide-first-impressions/
 
> Nice! The only real problem that I see is that you
> have to be running a windowing system.
 
Are there any IDEs (if you exclude emacs) that don't require a windowing
system?
 
--
Ian Collins
Lynn McGuire <lmc@winsim.com>: Sep 10 03:28PM -0500

"JetBrains CLion C++ IDE First Impressions"
http://cpprocks.com/jetbrains-clion-c-ide-first-impressions/
 
Nice! The only real problem that I see is that you
have to be running a windowing system. I do not run
a windowing system on my FreeBSD web server so I
cannot use it.
 
Lynn
Lynn McGuire <lmc@winsim.com>: Sep 12 03:49PM -0500

On 9/10/2014 5:46 PM, Ian Collins wrote:
 
>> Nice! The only real problem that I see is that you
>> have to be running a windowing system.
 
> Are there any IDEs (if you exclude emacs) that don't require a windowing system?
 
Wasn't there a version of Turbo C++ that ran on
DOS?
 
Of course, there was a version of Turbo C for
DOS. I used it and Turbo Pascal religiously.
 
Lynn
glen stark <g.a.stark@gmail.com>: Sep 11 01:29PM

> one of the purposes of that keyword. Does it allow for easier reading
> of the code? I don't know, depends on whom you ask. But I am not
> arguing about that either.
 
 
It may be my wording could be better, I'll put some thought into it.
What I wanted to convey was that it's possible to imagine a case where
auto saves you some effort typing, but makes the code less readable.
This is a bad usage of auto. On the other hand, it may make the code
more readable, an obvious example being using auto declare an iterator.
This is good usage of auto.
Lynn McGuire <lmc@winsim.com>: Sep 11 12:16PM -0500

On 9/11/2014 10:58 AM, Christopher Pisz wrote:
> compiler specific problem, or did I misunderstand how to do this?
 
> std::vector<std::string> test = {"foo","bar"};
 
> I'd like to set up a static const at the top of my cpp to define a collection of strings.
 
I put this in my software about 15 years ago. Our software
was originally written in smalltalk and had the concept of
tuples well embedded in it. Works well but the language
lawyers hate it with a passion:
 
// try to model a tuple somewhat but with rigorous type checking
 
vector <string> tupleString ()
{
vector <string> aVectorOfstrings (0);
 
return aVectorOfstrings;
}
 
 
vector <string> tupleString (string string1)
{
vector <string> aVectorOfstrings (1);
aVectorOfstrings [0] = string1;
 
return aVectorOfstrings;
}
 
 
vector <string> tupleString (string string1, string string2)
{
vector <string> aVectorOfstrings (2);
aVectorOfstrings [0] = string1;
aVectorOfstrings [1] = string2;
 
return aVectorOfstrings;
}
 
And so and so forth. I have all the way up to 69 strings:
 
vector <string> tupleString (string string1, string string2, string string3,
string string4, string string5,
string string6, string string7, string string8,
string string9, string string10, string string11,
string string12, string string13, string string14,
string string15, string string16, string string17,
string string18, string string19, string string20,
string string21, string string22, string string23,
string string24, string string25, string string26,
string string27, string string28, string string29,
string string30, string string31, string string32,
string string33, string string34, string string35,
string string36, string string37, string string38,
string string39, string string40, string string41,
string string42, string string43, string string44,
string string45, string string46, string string47,
string string48, string string49, string string50,
string string51, string string52, string string53,
string string54, string string55, string string56,
string string57, string string58, string string59,
string string60, string string61, string string62,
string string63, string string64, string string65,
string string66, string string67, string string68,
string string69)
{
vector <string> aVectorOfstrings (69);
aVectorOfstrings [0] = string1;
aVectorOfstrings [1] = string2;
aVectorOfstrings [2] = string3;
aVectorOfstrings [3] = string4;
aVectorOfstrings [4] = string5;
aVectorOfstrings [5] = string6;
aVectorOfstrings [6] = string7;
aVectorOfstrings [7] = string8;
aVectorOfstrings [8] = string9;
aVectorOfstrings [9] = string10;
aVectorOfstrings [10] = string11;
aVectorOfstrings [11] = string12;
aVectorOfstrings [12] = string13;
aVectorOfstrings [13] = string14;
aVectorOfstrings [14] = string15;
aVectorOfstrings [15] = string16;
aVectorOfstrings [16] = string17;
aVectorOfstrings [17] = string18;
aVectorOfstrings [18] = string19;
aVectorOfstrings [19] = string20;
aVectorOfstrings [20] = string21;
aVectorOfstrings [21] = string22;
aVectorOfstrings [22] = string23;
aVectorOfstrings [23] = string24;
aVectorOfstrings [24] = string25;
aVectorOfstrings [25] = string26;
aVectorOfstrings [26] = string27;
aVectorOfstrings [27] = string28;
aVectorOfstrings [28] = string29;
aVectorOfstrings [29] = string30;
aVectorOfstrings [30] = string31;
aVectorOfstrings [31] = string32;
aVectorOfstrings [32] = string33;
aVectorOfstrings [33] = string34;
aVectorOfstrings [34] = string35;
aVectorOfstrings [35] = string36;
aVectorOfstrings [36] = string37;
aVectorOfstrings [37] = string38;
aVectorOfstrings [38] = string39;
aVectorOfstrings [39] = string40;
aVectorOfstrings [40] = string41;
aVectorOfstrings [41] = string42;
aVectorOfstrings [42] = string43;
aVectorOfstrings [43] = string44;
aVectorOfstrings [44] = string45;
aVectorOfstrings [45] = string46;
aVectorOfstrings [46] = string47;
aVectorOfstrings [47] = string48;
aVectorOfstrings [48] = string49;
aVectorOfstrings [49] = string50;
aVectorOfstrings [50] = string51;
aVectorOfstrings [51] = string52;
aVectorOfstrings [52] = string53;
aVectorOfstrings [53] = string54;
aVectorOfstrings [54] = string55;
aVectorOfstrings [55] = string56;
aVectorOfstrings [56] = string57;
aVectorOfstrings [57] = string58;
aVectorOfstrings [58] = string59;
aVectorOfstrings [59] = string60;
aVectorOfstrings [60] = string61;
aVectorOfstrings [61] = string62;
aVectorOfstrings [62] = string63;
aVectorOfstrings [63] = string64;
aVectorOfstrings [64] = string65;
aVectorOfstrings [65] = string66;
aVectorOfstrings [66] = string67;
aVectorOfstrings [67] = string68;
aVectorOfstrings [68] = string69;
 
return aVectorOfstrings;
}
 
I will post the rest and the prototypes if needful.
 
Lynn
Geoff <geoff@invalid.invalid>: Sep 12 02:29PM -0700

On Fri, 12 Sep 2014 15:47:53 -0500, Lynn McGuire <lmc@winsim.com>
wrote:
 
>Can MSVC 2013 even produce executables for Windows XP?
>Vista? 7?
 
Yes. It produces executables for WIN32, this includes NT, 2000, Vista,
XP, 7, 8.x. It can also produce x64 binaries for the Windows 64 bit
OS. It can be used to produce command line tools as well and programs
written in standard C. You might have to deliver a runtime library
with your application, but you can test for that. I have even
translated a C console program to C# just for the fun of it.
 
I hit a few stumbling blocks upgrading from Visual Studio 6.0 to
VS2010 but once I had my projects converted to the new tools I have
never looked back. I think there might be some pain involved going
from VS2005 to VS2013 and you might have to use VS2008 as an
intermediate step if you want to automate the conversion but a lot
depends on the nature of your project and the language and libraries
you're using.
 
Between MS and their tools and frameworks du jour (COM, MFC, ATL,
etc...) and Apple with their variants of Xcode tools and frameworks
they can keep you pretty busy.
 
--
"Now, here, you see, it takes all the running you can do, to keep in
the same place. If you want to get somewhere else, you must run at
least twice as fast as that!" -- The Red Queen
Victor Bazarov <v.bazarov@comcast.invalid>: Sep 11 02:14PM -0400

On 9/11/2014 1:49 PM, Christopher Pisz wrote:
 
>> I will post the rest and the prototypes if needful.
 
>> Lynn
 
> Time to fire up the Notepad++ macros! Thanks, I'll give it a shot.
 
You're probably better off using intermediate arrays for that:
 
string _4v_[] = { "foo", "bar" }; // or more
vector<string> test(_4v_, _4v_ + sizeof(_4v_)/sizeof(*_4v_));
 
V
--
I do not respond to top-posted replies, please don't ask
Christopher Pisz <nospam@notanaddress.com>: Sep 11 12:49PM -0500

On 9/11/2014 12:16 PM, Lynn McGuire wrote:
> }
 
> I will post the rest and the prototypes if needful.
 
> Lynn
 
Time to fire up the Notepad++ macros! Thanks, I'll give it a shot.
Juha Nieminen <nospam@thanks.invalid>: Sep 12 11:10AM

> I read that we could use the following syntax in C++11 with standard
> containers. This is not working for me in msvc 2012.
 
MSVC 2012 is too old. It doesn't support all of C++11.
 
--- news://freenews.netfront.net/ - complaints: news@netfront.net ---
Christopher Pisz <nospam@notanaddress.com>: Sep 11 10:58AM -0500

I read that we could use the following syntax in C++11 with standard
containers. This is not working for me in msvc 2012. Is it a compiler
specific problem, or did I misunderstand how to do this?
 
std::vector<std::string> test = {"foo","bar"};
 
I'd like to set up a static const at the top of my cpp to define a
collection of strings.
Lynn McGuire <lmc@winsim.com>: Sep 11 02:59PM -0500

>> I will post the rest and the prototypes if needful.
 
>> Lynn
 
> Time to fire up the Notepad++ macros! Thanks, I'll give it a shot.
 
tuple.h file:
 
// tuple.h
 
 
// 09/28/09 Lynn McGuire add tuple with 60 items
// 10/21/09 Lynn McGuire add tupleString with 69 items
// 11/13/09 Lynn McGuire add std:: namespace declaration
// 11/16/10 Lynn McGuire add more tupleStrings
 
 
#ifndef __tuple_h__
#define __tuple_h__
 
 
// NOTE: tuple must be an base method for it to work on outside methods
 
std::vector <int> tuple ();
std::vector <int> tuple (int int1);
std::vector <int> tuple (int int1, int int2);
std::vector <int> tuple (int int1, int int2, int int3);
std::vector <int> tuple (int int1, int int2, int int3, int int4);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23, int int24);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23, int int24, int int25);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23, int int24, int int25,
int int26);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23, int int24, int int25,
int int26, int int27);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23, int int24, int int25,
int int26, int int27, int int28);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23, int int24, int int25,
int int26, int int27, int int28, int int29);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23, int int24, int int25,
int int26, int int27, int int28, int int29, int int30);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23, int int24, int int25,
int int26, int int27, int int28, int int29, int int30,
int int31);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23, int int24, int int25,
int int26, int int27, int int28, int int29, int int30,
int int31, int int32);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23, int int24, int int25,
int int26, int int27, int int28, int int29, int int30,
int int31, int int32, int int33);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23, int int24, int int25,
int int26, int int27, int int28, int int29, int int30,
int int31, int int32, int int33, int int34);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23, int int24, int int25,
int int26, int int27, int int28, int int29, int int30,
int int31, int int32, int int33, int int34, int int35);
std::vector <int> tuple (int int1, int int2, int int3, int int4, int int5,
int int6, int int7, int int8, int int9, int int10,
int int11, int int12, int int13, int int14, int int15,
int int16, int int17, int int18, int int19, int int20,
int int21, int int22, int int23, int int24, int int25,
int int26, int int27, int int28, int int29, int int30,
int int31, int int32, int int33, int int34, int int35,
int int36, int int37, int int38, int int39, int int40,
int int41, int int42, int int43, int int44, int int45,
int int46, int int47, int int48, int int49, int int50,
int int51, int int52, int int53, int int54, int int55,
int int56, int int57, int int58, int int59, int int60);
 
std::vector <std::string> tupleString ();
std::vector <std::string> tupleString (std::string string1);
std::vector <std::string> tupleString (std::string string1, std::string string2);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5, std::string string6);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8,
std::string string9);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8,
std::string string9, std::string string10);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8,
std::string string9, std::string string10, std::string string11);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8,
std::string string9, std::string string10, std::string string11,
std::string string12);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8,
std::string string9, std::string string10, std::string string11,
std::string string12, std::string string13);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8,
std::string string9, std::string string10, std::string string11,
std::string string12, std::string string13, std::string string14);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8,
std::string string9, std::string string10, std::string string11,
std::string string12, std::string string13, std::string string14,
std::string string15);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8,
std::string string9, std::string string10, std::string string11,
std::string string12, std::string string13, std::string string14,
std::string string15, std::string string16);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8,
std::string string9, std::string string10, std::string string11,
std::string string12, std::string string13, std::string string14,
std::string string15, std::string string16, std::string string17);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8,
std::string string9, std::string string10, std::string string11,
std::string string12, std::string string13, std::string string14,
std::string string15, std::string string16, std::string string17,
std::string string18);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8,
std::string string9, std::string string10, std::string string11,
std::string string12, std::string string13, std::string string14,
std::string string15, std::string string16, std::string string17,
std::string string18, std::string string19);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8,
std::string string9, std::string string10, std::string string11,
std::string string12, std::string string13, std::string string14,
std::string string15, std::string string16, std::string string17,
std::string string18, std::string string19, std::string string20);
std::vector <std::string> tupleString (std::string string1, std::string string2, std::string string3,
std::string string4, std::string string5,
std::string string6, std::string string7, std::string string8,
std::string string9, std::string string10, std::string string11,
std::string string12, std::string string13, std::string string14,
std::string string15, std::string string16, std::string string17,
std::string string18, std::string string19, std::string
Lynn McGuire <lmc@winsim.com>: Sep 12 03:47PM -0500

On 9/12/2014 6:10 AM, Juha Nieminen wrote:
>> I read that we could use the following syntax in C++11 with standard
>> containers. This is not working for me in msvc 2012.
 
> MSVC 2012 is too old. It doesn't support all of C++11.
 
Oh man, I hate to think of what you think about MSVC
2005 which we are stuck on.
 
Can MSVC 2013 even produce executables for Windows XP?
Vista? 7?
 
Lynn
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.lang.c+++unsubscribe@googlegroups.com.
Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)