Why does this no syntax error nested class program produce garbage output, and how do I fix it? - g++

Question

The following code includes a complete description of the problem as a TODO.
Included are cut/pasteable command lines to compile the code (without error).
Child instances contain their own name, and the initializer should copy it.
Child instances also contain a pointer to their Parent this instance.
Neither of these should print garbage.
Child also uses its Parent instance pointer to print the parent name.
This name is initialized by the Parent ctor, and so should not print as garbage.
I even ran it through clang with -fsyntax-only, without reported warning/error.
I must be missing something. Help would be appreciated.
////////////////////////////////////////////////////////////////////////////////
//
// ##### ## ##### ###### # # ##### #### ##### #####
// # # # # # # # ## # # # # # # # #
// # # # # # # ##### # # # # # # # # #
// ##### ###### ##### # # # # # ### # ##### #####
// # # # # # # # ## # ### # # # #
// # # # # # ###### # # # ### #### # #
////////////////////////////////////////////////////////////////////////////////
// A class having access to all nested class instances and vice versa
// 0. presence by name in a set
// 1. by name in a map
// 2. by index in a vector
// 3. by name to index in a map
// and nested classes have access to parent and to each other through parent.
////////////////////////////////////////////////////////////////////////////////
// TODO produce the following instead of garbage output.
// Compile and expected output:
// $ g++ --std=c++17 -Wall -pedantic -o parent parent.cpp
// $ ./parent
// P:A
// P:B
// $
////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>
using namespace std;
// Utility function for when things go wrong.
template<class... Args> void panic(Args... args) {
cerr << "parent panic: ";
(cerr << ... << args) << "\n";
exit(1);
}
class Parent { public: //CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
class Child { public: //cccccccccccccccccccccccccccccccccccccccccccccccccccc
Child(Parent* p, const string& n) : parent(p), name(n) {} // Child ctor
~Child() {} // Child dtor
void operator()(){ cout<<parent->name<<':'<<name<<endl; } // Child ftor
Parent* parent; // Child Parent ptr
const string& name; // Child name
}; //ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
Parent(const string& name) : name(name) {} // Parent ctor
~Parent() {} // Parent dtor
void operator()() { for(auto child: vcci) { child(); } } // Parent ftor
void operator+=(const vector<string>& names) {
for(auto name : names) {
if (used.find(name) != used.end()) panic(name, " re-used,");
used.insert(name); // Fast search
size_t vcN = vcci.size(); // Index for next name
vcci.emplace_back(this, name); // construct child into vector
Child* back = &(vcci[vcN]); // Address of child to store
mptr[name] = back; // Store address of child
mint[name] = vcN; // map name to index
}
}
string name; // name of parent
set<string> used; // fast lookup of name for duplicates
vector<Child> vcci; // vector of emplaced Child instances
map<string, Child*> mptr; // name lookup of Child pointer
map<string, size_t> mint; // index of name
}; //CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
//eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
void experiment() {
vector<string> AB = { "A", "B" }; // Names to use as Child names
Parent parent("P"); // Named parent
parent += AB; // Produce named Child instances
parent(); // Execute parent ftor
}
//mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
int main(int argc, char** argv) {
experiment();
return 0;
}

Answer 1

With for(auto name : names) ..., name is a local variable that's a copy of the string from the vector. That variable is created and destroyed on each iteration of the loop. Then you create Child instances with name as an argument - they store a reference to that variable in their name member. Soon afterwards, the variable is destroyed and all those references become dangling.
By the time the program actually tries to use Child::name members, the strings are long gone, and the references are long dangling. Any attempt to use them exhibits undefined behavior, by way of accessing an object after its lifetime has ended.

Answer 2

const string& name; // Child name
This was the offending line.
It had to be a string, not a string reference.
Simple programmer error.
Thanks for reviewing and pointing me in a good direction.