std::vector<std::string> a la matriz char*

std::vector<std::string> a la matriz char*


Tengo un 02 que necesito usar para un 17 argumento de la función que dice 25 . He visto cómo convertir un 35 a 43 . Como recién llegado a 57 , estoy tratando de reconstruir cómo realizar esta conversión en cada elemento del vector y producir el 66 matriz.


He visto varias preguntas SO estrechamente relacionadas, pero la mayoría parece ilustrar formas de ir en la otra dirección y crear 71 .


Respuestas:


Puedes usar 85 como:


std::transform(vs.begin(), vs.end(), std::back_inserter(vc), convert);  

Lo que requiere que implementes 90 como:


char *convert(const std::string & s)
{
char *pc = new char[s.size()+1];
std::strcpy(pc, s.c_str());
return pc;
}


Código de prueba:


int main() {
std::vector<std::string> vs;
vs.push_back("std::string");
vs.push_back("std::vector<std::string>");
vs.push_back("char*");
vs.push_back("std::vector<char*>");
std::vector<char*> vc;
std::transform(vs.begin(), vs.end(), std::back_inserter(vc), convert);
for ( size_t i = 0 ; i < vc.size() ; i++ )
std::cout << vc[i] << std::endl;
for ( size_t i = 0 ; i < vc.size() ; i++ )
delete [] vc[i];
}

Salida:


std::string
std::vector<std::string>
char*
std::vector<char*>

Demostración en línea:http://ideone.com/U6QZ5


Puedes usar 101 donde sea que necesites 110 .


Tenga en cuenta que dado que estamos usando 122 para asignar memoria para cada 133 (en 146 función), tenemos que desasignar la memoria al final. Esto le da flexibilidad para cambiar el vector 150; puedes 160 más cadenas, elimine la existente de 172 y 184 (es decir, 193 seguirá siendo válido!


Pero si no desea esta flexibilidad, puede usar este 209 función:


const char *convert(const std::string & s)
{
return s.c_str();
}

Y tienes que cambiar 212 a 225 .


Ahora, después de la transformación, si cambia 239 insertando nuevas cadenas, o eliminando las antiguas, luego todas las 243 en 252 podría volverse inválido. Ese es un punto importante. Otro punto importante es que no necesitas usar 260 en tu código nunca más.


Algunas respuestas de código


std::transform(vs.begin(), vs.end(), std::back_inserter(vc), convert);
char *convert(const std::string &
s) { char *pc = new char[s.size()+1];
std::strcpy(pc, s.c_str());
return pc;
}
int main() {
std::vector<std::string>
vs;
vs.push_back("std::string");
vs.push_back("std::vector<std::string>");
vs.push_back("char*");
vs.push_back("std::vector<char*>");
std::vector<char*>
vc;
std::transform(vs.begin(), vs.end(), std::back_inserter(vc), convert);for ( size_t i = 0 ;
i <
vc.size() ;
i++ ) std::cout <<
vc[i] <<
std::endl;
for ( size_t i = 0 ;
i <
vc.size() ;
i++ ) delete [] vc[i];
}
std::string std::vector<std::string>
char* std::vector<char*>
const char *convert(const std::string &
s) { return s.c_str();
}
std::vector<const char *>
cStrArray;
cStrArray.reserve(origVector.size());
for(int index = 0;
index <
origVector.size();
++index) { cStrArray.push_back(origVector[index].c_str());
} //NO RESIZING OF origVector!!!! SomeCFunction(&cStrArray[0], cStrArray.size());
char ** arr = new char*[vec.size()];
for(size_t i = 0;
i <
vec.size();
i++){
arr[i] = new char[vec[i].size() + 1];
strcpy(arr[i], vec[i].c_str());
}
for(size_t i = 0;
i <
vec.size();
i++){
delete [] arr[i];
} delete [] arr;
std::vector<std::string>
strings = /* from somewhere */;
int nterms = /* from somewhere */;
// using std::transform is a possibility depending on what you want // to do with the result of the call std::for_each(strings.begin(), string.end(), [nterms](std::string&
s) { ModelInitialize(&s[0], nterms);
}
s = std::string(s.begin(), std::find(s.begin(), s.end(), '\0'));
typedef std::unique_ptr<char[]>
pointer;
std::vector<pointer>
args;
std::transform(strings.begin(), strings.end() , std::back_inserter(args) , [](std::string const&
s) ->
pointer {
pointer p(new char[s.size()]);
std::copy(s.begin(), s.end(), &p[0]);
return p;
});
std::for_each(args.begin(), args.end(), [nterms](pointer&
p) { ModelInitialize(p.get(), nterms);
});
const char*a="something";
////whatever it is here const char* retfunc(const char*a) { char*temp=a;
//process then return temp }
std::vector<char>
v;
char* c = &v[0];

No