Dotaz: C++ vrácení konstatního textu z funkce

[Šangala]

Po delší době se zabývám něčím „základním“ a narazil jsem si na záležitost vrácení konstantního textu z virtuální fce.

Tento příklad asi není moc super s ohledem na bezpečnost

virtual const char* getText() const
{
  const char *name = "text";
  return name;
};

Tento už je asi lepší (nebo ne?)

virtual void getText(std::string &name) const
{
  name = "text";
};

ale mě by zajímalo jak se takové věci dělají obecně „správně“.

---

---

Odpovědi

[martyone]

Zkuste si přeložit a spustit tento krátký prográmek:

#include <stdio.h>

void x() {      const char *abc = "abc"; printf("x: %p/%p\n", &abc, abc); }
void y() { x(); const char *abc = "abc"; printf("y: %p/%p\n", &abc, abc); }
void z() { y(); const char *abc = "abc"; printf("z: %p/%p\n", &abc, abc); }

int main()
{
	z();
	return 0;
}

To by Vás mělo přesvědčit, že tohle..

virtual const char* getText() const
{
  return "text";
};

..je v naprostém pořádku

[Šangala]

Nepochybuji o funkčnosti…, získáte tím ale ukazatel na místo, na které se můžete pokusit zapsat, tj. není to defensivní kopie.

[mrk]

A kde je problém? Veď tá funkcia vracia const char*, čiže pointer na konštantné pole znakov. (aj keď, dá sa to obísť pomocou const_cast)

A prečo nepoužijete návratový typ const std::string (hodnota, nie referencia)? std::string sa riadi zásadou copy-on-write, čiže samotné vytvorenie kópie je lacné, akurát sa možno zbytočne pracuje s počítadlom odkazov.

[martyone]

Jak řekl mrk, pokusit zapsat se můžete, ale bez const_cast to nepůjde a to je jiná kapitola. A pak, kus kódu který jsem napsal není o prokázání funckčnosti ale správnosti

[Šangala]

Trošku jsem se snažil lépe vysvětlit vo co mi go níže.

[vlastagf]

Nevraci to nahodou pointer na lokalni promennou?

[vlastagf]

Resp. co vlastne vola?

return "text";

Alokuje se dynamicke pole nebo ne?

[Jirka P]

Ne, proboha!

return "text";

vrací ukazatel na globální, konstantní pole.

[__dark__]

Oba příklady jsou správně, ale dělají neco jiného. V prvním příkladu vracíš ukazatel na "text", v druhém vytváříš jeho kopii.

[Šangala]

Vím co ty fce dělají a ten rozdíl mi jde, ... je možné napsat další roj variant (neřeším správnost s ohledem na syntaxi a práce s pamětí :)).
Zajímalo mě jak se to bezpečně reší v praxi v roce 2010 :).
Varianta s char * umožní získat ukazatel do konstanty.

#include <iostream>
const char* getText() { return "Text"; }
int main()
{
  std::cout << getText() << std::endl;
  char *ch = (char *) getText();
  ch[0] = 't';
  std::cout << getText() << std::endl;
  return 0;
}

... že to skončí s Segmentation fault, je jiná záležitost.

2. Příklad již dává defensivní kopii, takže asi OK, ale zas práce s tím může být pracnější (víc psaní).
Starší kódy jsou plné vracení ukazatele na konstatní řetězec(char[]).
Vzhledem k tomu, že to má být součástí veřejného rozhraní, tak jsem chtěl zadiskutovat, jak je to správné řešit s ohledem na správný/bezpečný návrh a pohodlné použití.
Ono asi bude rozumná, mnou úmyslně neuvedená varianta a zde vzpomenutá varianta s vracením std::string hodnotou.

[jekub]

char *ch = (char *) getText();

1. chcete pouzivat c++, takze kdyz tak const_cast

2. je to vedome poruseni restrikce const char *. Fce vracejici ukazatel na konstantu je zcela v poradku. Ostatne pokud budete chtit, muzete zpusobit pad aplikace i v pripade navratu std::string hodnotou...

[Šangala]

ad. 1 - Já ano(i když si tím někdy nejsem jistý - jestli chci :) ), ale jak jsem psal jedná se o rozhraní a nevím kdo jak jej bude používat :)
ad. 2 - jo je to vědomé porušení a asi by to mělo stačit k tomu, že tím pádem je to „dostačující“ argument proto se tím nezabývat
Možná jsem to měl napsat nějak jinak, mě hlavně zajímá, která s variant je nejrozumnější, víceméně nenavádějící k jednoduchým chybám a obecně přijatelná.
Osobně preferuji bod 1. tj. vrácení ukazatele na konstantu, bo je to takové „milé“ a historicky mi vlastní :).
Nicméně setkávám se v novějších zdrojích s jinými variantami, což se dřív tak nevidělo, a protože fčul je rozhodnutí na mě, ale nejedná se o vnitřní záležitost, ale o veřejné rozhraní, tak jsem raději položil tento dotaz abych se něco dozvěděl.

Já vím, že v zásadě jde o nic a jsou daleko důležitější věci, ale ve své podstatě mezi některými variantami nevidím rozdíl co do funkčnosti/použitelnosti a chtěl jsem vědět proč to někdo dělá tak a někdo tak --- ty důvody mě zajímají, že by žádné nebyly?

[jekub]

Ty duvody jsou podle me tehoz druhu jako rozhodovani mezi tim, zda se ta funkce v prikladu bude jmenovat getText, GetText nebo treba get_text. Hlavni podle me je, aby byl styl v ramci Vaseho rozhrani konzistentni.

[biolog]

Obě dělají zhruba totéž.

Použít obyčejný Cčkový cast v C++ je možné a podporované. Ale C++ umí jemnější casty, lépe z nich lze poznat, co autor kdysi zamýšlel (jen odstranit const-nost, jen přetypovat na potomka a ne z čehokoliv, ...). Samozřejmě každé přetypování je určité nebezpečí. Když někdo udělá to co v příspěvku #6, dobře mu tak.

Chytré string používají copy-on-write a počítání referencí (nebo kombinaci s eager-copy). Pokud by byl ten vracený string velký, vytvářela by se pokaždé nová kopie. (Chytré stringy nemohou zvyšovat počitadlo referencí u char* stringu, protože ho nemá.) V tom případě je místo statického C stringu mít statický std::string a vracet jeho (líné) kopie.

Varianta getText(std::string &name) se hůř používá, protože volající musí mít lokální proměnnou na něco, co ho možná nezajímá. Třeba by chtěl zavolat foo(getText()) a nemůže.

Když tu druhou variantu upravíte aby vracela std::string (bez &), a ne void, budou skoro stejně dobré. Ledaže by volající preferovali CString (MFC), QString (Qt), wxString (wxWidgets), GString (GTK) nebo bůhvíco.

[Šangala]

A otočme to, co by jste použil v tomto případě a proč - snad to z někoho vytáhnu :).
(Vracíme ASCII řetězec „vyšší“ typy nepřichází v úvahu, na výběr je jen char* nebo std::string).

[martyone]

Pokud teda jde jen o styl, upřednostnil bych API vracející nějaký chytrý string. Práce s hodnotou je pohodlnější, nepotřebuje komentáře ohledně zodpovědnosti o dealokaci, a implementace se sdílenými daty nepřinášejí zas tak velké zatížení.

[:::]

ja bych vracel "char const *", pokud nemas duvod vracet std::string. Precejenom kdyz z toho uzivatel bude chtit udelat string, tak to neni problem a bude to efektivnejsi

btw. tim copy-on-write o kterym pise "biolog" bych si nebyl tak jistej. Pokud vim tak vetsina STL implementaci to nepouziva protoze to zpusobuje problemy u multithread aplikaci...

[Šangala]

Děkuji všem, rozhodl jsem se zůstat při starém tudíž, vracet

const char *

z důvodů:

• Dicki sem to tak dělal, nebyl-li ke změně nějaký vyšší důvod
• Je to takové jednoduché, z mého pohledu „průhledné“
• Nikdo nenamítl nic, co by to nějak shodilo