Ir ao conteúdo
  • Cadastre-se

como sobrecarregar o tipo char*?


Cambalinho

Posts recomendados

eu fiz 1 class que necessito que o resultado saia em char *, mas da-me erro:


private:

string result;
public:

operator char*()
{
char * t=result.c_str();
return t;
}

erro: "invalid conversion from 'const char*' to 'char*' [-fpermissive]"

porque este erro? o que estou a fazer mal nesta funçao de sobrecarga?

Link para o comentário
Compartilhar em outros sites

"Oi"

O codigo acima é do tipo const char* e não char*

mas o problema nao foi esse:

operator char*()
{
char *cstr = new char[result.length() + 1];
strcpy(cstr, result.c_str());
return cstr;
}

e agora esta correcto.

mas tenho 1 duvida: nao deveria usar o 'delete' para limpara a memoria?

Link para o comentário
Compartilhar em outros sites

#include <iostream>
#include <vector>
#include <string>

class P
{
private:
std::string result;
public:
P(char *p)
{
result = p;
}
operator char*()
{
return (char*) result.c_str();;
}
};

int main()
{
P p("Hello");

std::cout << p;

getchar();
}

Faça Unboxing, não recomento usar malloc e retornar o ponteiro através de operator, vai ter que lembrar disso sempre que chamar a função.

Pior, se chamar um cout << p; perderá o ponteiro criado, e só será deletado no encerramento do programa.

porém se vai retornar um c_str() de uma string, faça assim.

class P
{
private:
std::string result;
public:
P(char *p)
{
result = p;
}
operator const char*()
{
return result.c_str();;
}
};

Link para o comentário
Compartilhar em outros sites

#include <iostream>
#include <vector>
#include <string>

class P
{
private:
std::string result;
public:
P(char *p)
{
result = p;
}
operator char*()
{
return (char*) result.c_str();;
}
};

int main()
{
P p("Hello");

std::cout << p;

getchar();
}

Faça Unboxing, não recomento usar malloc e retornar o ponteiro através de operator, vai ter que lembrar disso sempre que chamar a função.

Pior, se chamar um cout << p; perderá o ponteiro criado, e só será deletado no encerramento do programa.

porém se vai retornar um c_str() de uma string, faça assim.

class P
{
private:
std::string result;
public:
P(char *p)
{
result = p;
}
operator const char*()
{
return result.c_str();;
}
};

muito obrigado amigo. obrigado

olha como posso sobrecarregar o operador string?

operator string()
{
return result.c_str();
}

porque da-me erro:

"ambiguous overload for 'operator=' (operand types are 'std::string {aka std::basic_string<char>}' and 'Variant')"

o que me podes dizer sobre este erro?

eis o teste:

int main()
{
string c;
double i=2100;
Variant b="dsfgdsfd";
c=b;//o erro é aqui
cout << c;
return 0;
}

eu posso usar o operador '=' em vez do 'string', mas linha fica desta forma:

c=(string)b;

eu queria evitar aquele casting.

Link para o comentário
Compartilhar em outros sites

Só para eu saber, pra que esse maldito char*? que nem const é. Pelo menos coloque const nele, mas prefiro que use string&.

Matheus bom post, só pra chover no molhado prefira a nova inicialização do C++11 quando possível {}. Existem várias vantagens que você pode ver na internet.


class P
{
private:
std::string result;
public:
P(const std::string& s)
{
result = s;
}

operator std::string()
{
return result;
}
};

int main()
{
P p{ "Hello" };
std::string s{ p };

std::cout << s;

getchar();
}

Link para o comentário
Compartilhar em outros sites

Só para eu saber, pra que esse maldito char*? que nem const é. Pelo menos coloque const nele, mas prefiro que use string&.

Matheus bom post, só pra chover no molhado prefira a nova inicialização do C++11 quando possível {}. Existem várias vantagens que você pode ver na internet.


class P
{
private:
std::string result;
public:
P(const std::string& s)
{
result = s;
}

operator std::string()
{
return result;
}
};

int main()
{
P p{ "Hello" };
std::string s{ p };

std::cout << s;

getchar();
}

desculpa, mas continuo com erros :(

#include <iostream>
#include <string>

using namespace std;

class Variant
{
private:

string result;

public:

Variant()
{
}

template <typename T>
Variant(T val)
{
result=to_string(val);
}

Variant(const string val)
{
result=val;
}

Variant(const char* val)
{
result=val;
}

Variant(const char val)
{
result=val;
}

Variant(bool val)
{
result=to_string(val);

if (result=="0")
{
result="false";
}
else
{
result="true";
}
}

friend ostream& operator<< (ostream &out, Variant &VResult)
{
out <<VResult.result;
return out;
}

friend istream& operator >> (istream &in, Variant &VResult)
{
getline(in,VResult.result);
return in;
}

operator double()
{
return atof(result.c_str());
}

operator string()
{
return result;
}

operator char*()
{
return (char*) result.c_str();
}
};

int main()
{
string c;
Variant b="dsfgdsfd";
c=b;//erro
cout << c;
return 0;
}

mensagem de erro:

"ambiguous overload for 'operator=' (operand types are 'std::string {aka std::basic_string<char>}' and 'Variant')"

o que estou a fazer mal com o string?

Link para o comentário
Compartilhar em outros sites

Use explicit


explicit operator string()
{
return result;
}

Perceba que de forma nenhuma concordo com o que você está fazendo, mas também não julgo.

/*explicit operator string()
{
return result;
}*/

operator char*()
{
return (char *) result.c_str();
}

ja entendi 1 cena: parece que o compilador nao reconhece correctamente entre char* e string.

meto 1 a funcionar, falha o outro.

o que me aconcelhas?

Link para o comentário
Compartilhar em outros sites

apos mais estudos e mais esforço consegui:

#include <iostream>
#include <string>

using namespace std;

class Variant
{
private:
string result;

public:
Variant() : result("")
{
;
}


Variant (const double &v)
{
result=v;
}

Variant(char &v)
{
result=v;
}

Variant(const char &v)
{
result=v;
}

Variant(const string &v) : result(v)
{
;
}

Variant(const char *v) : result(v)
{
;
}

Variant( char *v) : result(v)
{
;
}

Variant(bool v) : result(v?"true":"false")
{
;
}

template<typename T>
Variant( T val)
{
result=to_string(val);
}

friend ostream& operator<< (ostream &out, Variant &v)
{
out << v.result;
return out;
}

friend istream& operator>> (istream &in, Variant &v)
{
getline (in, v.result);
return in;
}

operator char*()
{
return (char*)result.c_str();
}

explicit operator int()
{
return atoi(result.c_str());
}
};


int main()
{
string c="oi";
Variant b =c;
cout << b << endl;
c =b;
cout << c << endl;
return 0;
}

só tenho mais 1 questao: como posso sobrecarregar o char sem influenciar com:

operator char*()
{
return (char*)result.c_str();
}

????

Link para o comentário
Compartilhar em outros sites

Documentação diz...

C++98

const char* c_str() const;

Você não influenciou, você violou.

Vou explicar mais, o ponteiro é de conteúdo const, pois está compartilhando um recurso de dentro da classe, não é do interesse da classe string ter seu conteúdo modificado por terceiros através de ponteiro.

Se você quer devolver um ponteiro char* crie uma cópia antes desvinculando a string do novo conteúdo.

Link para o comentário
Compartilhar em outros sites

Arquivado

Este tópico foi arquivado e está fechado para novas respostas.

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...