Запись вектора строк в массив указателей на тип char

vector<string> str_vec;           // вектор строк, введеных с клавиатуры
int main()
{   string s_temp;               // в данный момент исполняет функцию переменной текущей прочитанной строки
                                          // котороая будет записана в конец вектора строк.
 
    while(cin >> s_temp)                            // пока есть ввод
        str_vec.push_back(s_temp);      // добавлять в конец вектора строку s_temp
 
// ВОТ ТУТ самое сложное и непонятное мне
        const char **p_arr = new const char *[str_vec.size()];               //создаю указатель на первый элемент
// динамического массива, каждый элемент которого является указателем. Т.б. получается указатель на указатель. 
//Предполагется что этот указатель всегда будет указывать на 1й элемент массива.
 
        const char **p_to_arr=p_arr; // создаю указатель, которым буду перебирать массив указателей, и 
//присваиваю ему начальное значение начала массива. (Опять же, получается это указатель на указатель)
 
        
        for (vector<string>::iterator str_it=str_vec.begin();str_it!=str_vec.end();++str_it, ++p_to_arr) // здесь 
// итератором читаю каждый элемент вектора, и записываю его в переменную s_temp, которая теперь выполняет 
//функцию хранения текущей строки для последущей записи указателя на отвечающую ей С-stryle строку в массив 
//указателей p_arr
        {
                s_temp=*str_it;
                *p_to_arr=s_temp.c_str(); // в 1м прогоне цикла  p_to_arr = p_arr, потом оно каждый раз 
// инкрементируется циклом for. 
 
//Как пишут .c_str(); - дает указатель на С-строку, который я записываю в ячейку массива указателей, в ту ячейку
// на которую указывает  p_to_arr.  Мне кажется, что ошибка где-то здесь в операторе присвоения.
                
        }
        
// Далее идет просто вывод на экран содержимого вектора, и содержимого массива указателей для сравнения
        for (vector<string>::iterator str_it=str_vec.begin();str_it!=str_vec.end();++str_it)
        {
            cout << *str_it << endl; // с вектором тут все нормально
        }
        _getch();
                
 
        for (p_to_arr=p_arr;p_to_arr!=p_arr+str_vec.size();++p_to_arr)
        {
            
            cout << *p_to_arr << endl;   // а вот тут проблема: все элементы на которые указывают указатели 
// из массива указателей, являются последним элементом вектора, т.б. последней введенной строкой
        }
    _getch();
    return 0;
}

s_temp="qqq";               //вообще я присвоил не напрямую, а как 1й элемент вектора, который был в тот момент равен "qqq"
p_arr[0]=s_temp.c_str();

 for (vector<string>::iterator str_it=str_vec.begin();str_it!=str_vec.end();++str_it, ++p_to_arr)
        {
                s_temp=*str_it;
                *p_to_arr=s_temp.c_str();
        }

        for (string::size_type ind=0;ind!=str_vec.size();++ind, ++p_to_arr)
        {
                *p_to_arr=str_vec[ind].c_str();
        }

 s_temp=*str_it;
*p_to_arr=s_temp.c_str();

char *ptrs_to_c_str[];

for (vector<string>::iterator str_it=str_vec.begin();str_it!=str_vec.end();++str_it,++p_to_arr)
          {        
        char *el = new char[str_it->size() + 1];
        strncpy(el, str_it->c_str(),str_it->size() + 1);
        *p_to_arr = el;
                  }

const char **p_to_arr=p_arr; // ok
........
*p_to_arr = str_it->c_str();   // ok

#include <iostream>
#include <string>
#include <vector>
#include <windows.h>
using namespace std;
int main(){
SetConsoleCP (1251); SetConsoleOutputCP (1251);
const int sz = 7;
char *source_c_str[] = {"Mama","мыла","Раму","Кришну", "Вишну", "вишню","раму"};//для простой инициализации массива. Дальше забудем о нём
////////////
vector<string> vec(source_c_str, source_c_str+sz);
//объявляем искомый массив указателей также как и source_c_str, а инициализирум позже:
char *output_c_str[sz];
vector<string>::iterator beg_it = vec.begin();
vector<string>::iterator end_it = vec.end();
int len_tmp=0;
int shift_in_output_c_str=0;
 
for(vector<string>::iterator it = beg_it; it != end_it; ++it){
    len_tmp=it->size()+1;
*(output_c_str+shift_in_output_c_str) = new char[len_tmp];
 
strcpy(*(output_c_str+shift_in_output_c_str), it->c_str());
shift_in_output_c_str++;
}
 
for(int i=0; i<sz; ++i)cout<<*(output_c_str+i)<<" ";
cout<<endl;
cout<<"Вернее:"<<endl;
cout<<*output_c_str<<" "<<*(output_c_str+1)<<" "<<*(output_c_str+6)<<"!"<<endl;
system("pause");
return 0;
}

#include <iostream>
 
typedef int* PtrToInt;
typedef const int* PtrToConstInt;
 
 
void Foo(PtrToInt*)
{
  std::cout << "PtrToInt*" << std::endl;
}
 
void Foo(PtrToConstInt*)
{
  std::cout << "PtrToConstInt*" << std::endl;
}
 
void Foo(const PtrToInt*)
{
  std::cout << "const PtrToInt*" << std::endl;
}
 
void Foo(const PtrToConstInt*)
{
  std::cout << "const PtrToConst*" << std::endl;
}
 
int main ()
{
  {
    int** p = 0;        // неконстантный указатель на неконстантный указатель на инт
    int** const pc = 0; // константный указатель на неконстантный указатель на инт
    Foo(p);
    Foo(pc);
 
    /*
    p = 0;      // ок.  p   - не константа
    *p = 0;     // ok.  p   - указывает на неконстанту
    *(*p) = 0;  // ok. (*p) - указывает на неконстанту
 
    //pc = 0;    // error. pс    - константа
    *pc = 0;     // ok.    pc    - указывает на неконстанту
    *(*pc) = 0;  // ok.    (*pc) - указывает на неконстанту
    */
  }
 
  {
    const int** p = 0;        // неконстантный указатель на неконстантный указатель на const int
    const int** const pc = 0; // константный указатель на неконстантный указатель на const int
    Foo(p);
    Foo(pc);
 
    /*
 
    p = 0;          // ок.     p   - не константа
    *p = 0;         // ok.     p   - указывает на неконстанту
    //*(*p) = 0;    // error. (*p) - указывает на константу
 
    //pc = 0;       // error.  pс   - константа
    *pc = 0;        // ok.     pc   - указывает на неконстанту
    //*(*cp) = 0;   // error. (*pc) - указывает наконстанту
 
    */
  }
 
  {
    int* const * p = 0;        // неконстантный указатель на константный указатель на инт
    int* const * const pc = 0; // константный указатель на константный указатель на инт
    Foo(p);
    Foo(pc);
 
    /*
    p = 0;      // ок.    p    - не константа
    //*p = 0;   // error. p    - указывает на константу
    *(*p) = 0;  // ok.    (*p) - указывает на неконстанту
 
    //pc = 0;    // error. pс    - константа
    //*pc = 0;   // ok.    pc    - указывает на константу
    *(*pc) = 0;  // error. (*pc) - указывает на неконстанту
    */
  }
 
  {
    const int* const * p = 0;        // неконстантный указатель на константный указатель на const int
    const int* const * const pc = 0; // константный указатель на константный указатель на const int
    Foo(p);
    Foo(pc);
 
    /*
    p = 0;        // ок.    p    - не константа
    //*p = 0;     // error. p    - указывает на константу
    //*(*p) = 0;  // error. (*p) - указывает на константу
 
    //pc = 0;    // error. pс    - константа
    //*pc = 0;   // error. pc    - указывает на константу
    //*(*pc) = 0;  // error. (*pc) - указывает на константу
    */
  }
 
  return 0;
}

 78   //*pc = 0;   // ok.    pc    - указывает на константу
 79   *(*pc) = 0;  // error. (*pc) - указывает на неконстанту

 //78 *pc = 0;   // ok.    pc    - указывает на константу

  int* const * const pc = 0; // константный указатель на константный указатель на инт
  //*pc = 0;   // error.  pc    - указывает на константу. менять нельзя