C++ class constructor clears map - c++

Question

My first constructor edits a member std::map and then calls another constructor. At the end of the first constructor the size of the map is 2, and at the start of the second constructor it's 0. What is causing this?
Here is my header file:
// Test.h
#include <map>
#include <string>
class Test
{
public:
Test(std::string name, int age);
private:
Test();
std::map<std::string, int> myMap_;
}
And here is my code:
// Test.cpp
#include "test.h"
Test::Test()
{
std::cout << myMap_.size() << std::endl; // Outputs 0
}
Test::Test(std::string name, int age)
{
myMap_.insert(name, age);
myMap_.insert("test", 6);
std::cout << myMap_.size() << std::endl; // Outputs 2
Test();
}
EDIT:
And here is my main function:
#include "test.h"
int main()
{
Test t("yo", 4);
return 0;
}

Answer 1

The second constructor inserts 2 elements. So the size is 2.
The first constructor inserts no elements. So the size is 0.
I guess maybe you expect Test(); inside the second constructor to "call the other constructor" for the same object. However this does not happen. Constructors are different to regular functions.
The code Test(); actually means to create a temporary object of type Test, which is initialized by calling the default constructor. Then that object is destroyed immediately, since it was temporary.
Constructors have no name, as far as name lookup is concerned, it's not possible to call them like regular functions. Instead they are invoked when you give the syntax to create an object.
If you want to have some common code that is shared by multiple constructors; you could either put that code in a function that is called by the multiple constructors, or use the delegating constructors feature. In the latter case, the delegation must happen before any statements inside the constructor body are executed.

Answer 2

You are not actually calling the constructor on the same object but create a temporary new one, which then has no name. See it as the same as this:
Test::Test(std::string name, int age)
{
myMap_.insert(name, age);
myMap_.insert("test", 6);
std::cout << myMap_.size() << std::endl; // Outputs 2
Test other = Test(); //you create a new object here
}
In C++11 you can do something like you want to do with this (this is called constructor delegation):
Test::Test(std::string name, int age)
:Test()
{
myMap_.insert(name, age);
myMap_.insert("test", 6);
std::cout << myMap_.size() << std::endl;
}
The difference here though is the Test() constructor will be called before the insert operations on the map.

Answer 3

You are creating two instances of a Test.
The first instance of a Test, which is constructed with the name and age, inserts elements into its myMap_ but the second instance does not.
When you call Test() in the Test(name, age) constructor it is creating a second instance of Test locally using the Test() constructor which does not insert into the map. This second instance would then be almost immediately destroyed (as it is not assigned to anything).
I think you are attempting to use two constructors on the same object, but that is only done for inheriting objects, where each derivation needs to call its own constructor and call its base.
You could create a function and call that instead:
// Test.h
#include <map>
#include <string>
class Test
{
public:
Test(std::string name, int age);
void OutputSize();
private:
Test();
std::map<std::string, int> myMap_;
}
Test::Test(std::string name, int age)
{
myMap_.insert(name, age);
myMap_.insert("test", 6);
OutputSize();
}
void Test::OutputName()
{
std::cout << myMap_.size() << std::endl; // Outputs 2
}