Windows Visual Studio C++ lists of lists - c++

Question

Windows lists
Found the following post somewhat helpful but I'm still struggling.
Creating list of lists in c++
What I require is a list of string lists.
So:
#include <list>
typedef list<std::string, allocator<std::string>>> LISTSTR;
typedef list<LISTSTR, allocator<LISTSTR>> LISTLISTSTR; // uncertain what this is doing?!!?
main()
{
LISTLISTSTR records;
// Add a blank string list to the list
LISTSTR *rowoffields = new LISTSTR();
rowoffields->insert(string("Field1"); // also tried new string("Field1")
records.insert(rowoffields); // also tried *rowoffields
}
But this returns the compile error :
no instance of overloaded function "std::list<_Ty,_Alloc>::insert[with _Ty=std::string, _Alloc=std::allocator<std:string>]" matches the argument list
argument types are (std::string) // or types are (std::string*) if using new string("Test")
object type is: LISTSTR
no instance of overloaded function "std::list<_Ty,_Alloc>::insert[with _Ty=LISTSTR, _Alloc=std::allocator<LISTSTR>]" matches the argument list
argument types are (LISTSTR*) // or types are (LISTSTR) if using *rowoffields
object type is: LISTLISTSTR

Answer 1

Here is one way to go about doing it that is perhaps a bit closer to Python's normal usage. We first declare an array of pointers to a list of strings (type-specified-up-front, not Python-duck-typed (though we could do that with templates). Then we use those pointers in a memory-safe fashion (no leaks) to make new lists. Notice in this specific setup that the total number of lists is fixed at compile-time (and is equal to const int SIZE), and the array of pointers lives on the stack, but the lists the pointers point to are all dynamically allocated on the heap. (You can do this with new and delete, but the newer smart pointers are really the way to go).
#include <list>
#include <memory> //for the smart pointers
#include <iostream>
const int SIZE = 3;
int main() {
//make an array of smart pointers to list of strings:
std::unique_ptr<std::list<std::string>> myLists[SIZE];
//use each smart pointer in the list to make a new list:
for (int i = 0; i < SIZE; i++) {
myLists[i] = std::make_unique<std::list<std::string>>();
}
//load each new list with a single string:
myLists[0]->push_front("Hello");
myLists[1]->push_front("World,");
myLists[2]->push_front("I'm C++!");
//print the results
for (int i = 0; i < SIZE; i++) {
std::cout << myLists[i]->front() << " ";
}
std::cout << std::endl;
return 0;
}
Now if you wanted to be able to add more lists to your list of lists at runtime, you'd have to dynamically allocate the array of pointers to list, rather than do it with static (automatic) allocation as in this example. (Edit: Or, you could set some upper limit, say 100, and then make that the max amount of lists in the application. Probably want to use a std::array to hold that list of pointers, rather than the plain array above, as std::array does bounds checking as with Python).
For the simpler version:
#include <list>
//remove typedefs
int main() { //notice the int!
const int SIZE = 10;
//make array of pointers to list of strings (on stack, fixed size)
std::list<std::string>* myLists[SIZE];
//use pointer to make new list on heap:
myLists[0] = new std::list<std::string>;
//use pointer syntax (instead of . use ->) to call list functions
myLists[0]->push_front("Old style C++");
//more code...
//when finished must remember to free that memory:
delete myLists[0];
//and not leave a dangling pointer:
myLists[0] = nullptr;
return 0;
}