como sobrecarregar o tipo char*?

Cambalinho · 18 de dezembro de 2013

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?

Matheus Maldi · 18 de dezembro de 2013

"Oi"

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

Cambalinho · 18 de dezembro de 2013

"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?

Matheus Maldi · 18 de dezembro de 2013

#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();;
	}
};

Cambalinho · 18 de dezembro de 2013

#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.

Matheus Maldi · 18 de dezembro de 2013

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

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

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

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

	std::cout << s;

	getchar();
}

isso que quer?

Edmorte · 19 de dezembro de 2013

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();
}

Cambalinho · 19 de dezembro de 2013

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?

Edmorte · 19 de dezembro de 2013


 operator string()
    {
        return result;
    }

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

E aí qual deles o compilador escolhe?

Cara sinceramente, para de misturar C com C++.

Cambalinho · 19 de dezembro de 2013


 operator string()
    {
        return result;
    }

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

E aí qual deles o compilador escolhe?

Cara sinceramente, para de misturar C com C++.

desculpa, mas eu quero que aceite os 2

Edmorte · 19 de dezembro de 2013

desculpa, mas eu quero que aceite os 2

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.

Cambalinho · 19 de dezembro de 2013

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?

Edmorte · 19 de dezembro de 2013

/*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?

estudar mais!

Cambalinho · 23 de dezembro de 2013

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();
    }

????

Edmorte · 24 de dezembro de 2013

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.