Ir ao conteúdo
  • Comunicados

    • Gabriel Torres

      Seja um moderador do Clube do Hardware!   12-02-2016

      Prezados membros do Clube do Hardware, Está aberto o processo de seleção de novos moderadores para diversos setores ou áreas do Clube do Hardware. Os requisitos são:   Pelo menos 500 posts e um ano de cadastro; Boa frequência de participação; Ser respeitoso, cordial e educado com os demais membros; Ter bom nível de português; Ter razoável conhecimento da área em que pretende atuar; Saber trabalhar em equipe (com os moderadores, coordenadores e administradores).   Os interessados deverão enviar uma mensagem privada para o usuário @Equipe Clube do Hardware com o título "Candidato a moderador". A mensagem deverá conter respostas às perguntas abaixo:   Qual o seu nome completo? Qual sua data de nascimento? Qual sua formação/profissão? Já atuou como moderador em algo outro fórum, se sim, qual? De forma sucinta, explique o porquê de querer ser moderador do fórum e conte-nos um pouco sobre você.   OBS: Não se trata de função remunerada. Todos que fazem parte do staff são voluntários.
    • DiF

      Poste seus códigos corretamente!   21-05-2016

      Prezados membros do Fórum do Clube do Hardware, O Fórum oferece um recurso chamado CODE, onde o ícone no painel do editor é  <>     O uso deste recurso é  imprescindível para uma melhor leitura, manter a organização, diferenciar de texto comum e principalmente evitar que os compiladores e IDEs acusem erro ao colar um código copiado daqui. Portanto convido-lhes para ler as instruções de como usar este recurso CODE neste tópico:  
joubet

Uso de sobrecarga com métodos em C++

Recommended Posts

:(

A rotina abaixo, está dando erro, acredito eu, porque estou querendo pasasar um parâmetro no método para o qual inicialmente foi declarado dois. Me foi dito, que para resolver a questão teria que fazer sobrecarga de métiodo, más eu não sei fazer isso. Se alguem puder ajudar.. Veja:

 
class calculando
{
public:
int arranjo (int n, int p);
float divisao (float dividendo, float divisor);
};

int calculando::arranjo (int n, int p) // Arranjo
{
int arranj = 0;
while (n >= p)
{
n = (n *(n -1));
p = (p *(p -1));
arranj = arranjo(n)/ arranjo(n - p);
};
return arranj;

Obrigado

Editado por jpc777

Compartilhar este post


Link para o post
Compartilhar em outros sites

Acho que o código abaixo resolve o seu problema.

declarando o método arranjo assim: int arranjo (int n, int p = 0); você define que p terá 0 como valor padrão, ou seja, quando o valor não for passado.

Tinha também uns outros errinhos. Dá uma olhada.


class calculando
{
public:
int arranjo (int n, int p = 0);
float divisao (float dividendo, float divisor);
};

int calculando::arranjo (int n, int p) // Arranjo
{

int arranj = 0;

while (n >= p)
{
n = (n *(n -1));
p = (p *(p -1));
arranj = arranjo(n)/ arranjo(n - p);
}

return arranj;
}

Compartilhar este post


Link para o post
Compartilhar em outros sites
  • Autor do tópico
  • :(

    A solução de se fazer a pré-inicialização de p =0, não atendeu. Ao rodar o programa ao informar os valores de N e P, recebi a mensagem de que o programa executou uma operação ilegal, provavelmente motivada pela pré-inicialização de p. Para melhor entender o problema, veja o arquivo .cpp, que chama os métodos da classe.

     
    #include <iostream>
    #include "calculo.h"
    int main()
    {
    int Nfat,valorN, valorP;

    calculando minhaclasse; // definindo a ocorrência da classe calculo

    cout << "Entre com Valor de N e Valor de P callcular o arranjo" << endl;
    cin >> valorN;
    cin >> valorP;
    cout << "Valor do Arranjo " << minhaclasse.arranjo (valorN,valorP) << endl;

    system ("pause");
    return 0;
    }

    Por isso estou falando em sobrecarga, que até onde sei permite fazer chamada de método com numero diferente de parâmetros, mas não sei fazer

    Obriigado.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Ok...



    class calculando
    {
    public:

    int arranjo (int n);
    int arranjo (int n, int p);
    float divisao (float dividendo, float divisor);
    };


    int calculando::arranjo (int n) // Arranjo
    {
    // código para apenas um parâmetro...
    }

    int calculando::arranjo (int n, int p) // Arranjo
    {

    int arranj = 0;

    while (n >= p)
    {
    n = (n *(n -1));
    p = (p *(p -1));
    arranj = arranjo(n)/ arranjo(n - p);
    }

    return arranj;
    }


    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • :(

    Considere o arquivo .cpp do post anterior, considere a alteração na classe abaixo:

    class calculando
    {
    public:
    int arranjo (int n, int p);
    int arranjo (int n);
    float divisao (float dividendo, float divisor);

    };

    int calculando::arranjo (int n) // Arranjo
    {
    if (n > 1)
    {
    return n * arranjo(n -1);
    }
    else
    {
    return 1;
    }
    }

    //========================================

    int calculando::arranjo (int n, int p) // Arranjo
    {

    int arranj = 0;

    while (n >= p)
    {
    n = (n *(n -1));
    p = (p *(p -1));
    arranj = arranjo(n)/ arranjo(n - p);
    }

    return arranj;
    }

    Ao compilar o programa deu tudo certo. Entretanto ao rodada –lo, recebi a seguinte mensagem:

    Este programa executou uma operação ilegal. Será fechado.....

    O que ainda está errado ?

    Obrigado

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    O problema está nessa linha: return n * arranjo(n -1);

    O programa entra num looping sem fim, por isso gera um erro. O que você está querendo fazer?

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • :(

    O que estou querendo fazer, é calcular o Arranjo Simples representado pela fórmula:

    A n,p = n! / (n –p)!

    Onde

    n! seria calculado pelo método de arranjo, que passaria apenas o parâmetro n

    n –p seria calculado pelo método de arranjo, que passaria os parâmetros n p

    daí a sobrecarga.

    A ideia é que no programa cliente cpp, eu passe os valores de n, p uma vez só como mostrado acima, ou seja:

    cout << "Entre com Valor de N e Valor de P calcular o arranjo" << endl;
    cin >> valorN;
    cin >> valorP;
    cout << "Valor do Arranjo " << minhaclasse.arranjo (valorN,valorP) << endl;

    Qual seria a alernativa para linha

    return n * arranjo(n -1);

    Imaginei, que esta linha calculasse o valor do fatorial de n na fórmula.

    Obrigado

    Editado por jpc777

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Tenta assim...


    int calculando::arranjo (int n) // Arranjo
    {
    int fatorial = n;

    while(n > 1)
    {
    fatorial *= (n-1);
    n--;
    }

    return fatorial;
    }


    int calculando::arranjo (int n, int p) // Arranjo
    {
    return arranjo(n)/ arranjo(n - p);
    }

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • :-BEER

    Ok, deu certo Agora, que a coisa foi resolvida na prática, seria interessante conceituar ou definir sobrecarga. Então o que seria sobrecarga de método ? eu tenho algumas idéias e gostaria de saber se estão certas. Vamos lá:

    1 - sobrecarga, seria um método, que é chamado mais de uma vez e com numero de parâmetros diferentes

    2 – O tipo base dos parâmetros passados num método devem ser mantidos durante a sobrecarga do método, ou seja, como no caso que estamos discutindo temos a sobrecarga de arranjo, onde num momento temos n e p como tipo base int e na sobrecarga temos somente n como int. Se n passasse a ser float não seria mais sobrecarga. Correto ?

    3 – No citado exemplo, o código do método arranjo, muda, desta forma posso afirmar que sobrecarga de método, se refere somente ao tipo base do parâmetro do método, e não ao código ?

    4 – Pelo fato do código variar, no exemplo acima, posso dizer, que tenho um exemplo de polimorfismo ou ainda não é o caso ?

    5 – Quando somente o nome do método permanece, o código e os tipos bases de parâmetros mudam, o que tenho ?

    Obrigaddo

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    (1), (2) e (3)

    Sobrecarga de métodos se refere ao uso de métodos com mesmo nome, mas com tipo de parâmetros diferentes. Isto é, o nome do método é o mesmo mas os tipos de parâmetros são diferentes. De um modo geral como os métodos sobrecarregados tem o mesmo nome, eles realizam basicamente a mesma tarefa, a diferença é o número de parâmetros e ou os tipos de parâmetros que são recebidos.

    [Texto retirado da apostila de André Duarte Bueno, USFC-LMPT-NPC]

    (4)

    Não. O polimorfismo seria uma espécie de "evolução" de um determinado código. Seria algo como pegar um código e melhorar ele, mas sem que ele perca suas características.

    Na mesma apostila, supracitada, o autor faz a seguinte analogia:

    "A palavra polimorfismo significa muitas formas, e representa o fato de uma determinada característica (potência de um motor) ser diferente para cada filho (Tipo de veículo). Quem já andou de Volks e de Mercedes sabe bem a diferença."

    (5)

    Não deixa de ser uma sobrecarga também, porém bastante incomum. Como dito anteriormente é "esperado" que ao criar métodos com mesmo nome eles tenham algo em comum.

    Espero ter ajudado.

    Abraço.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • :o

    Pelo que entendi, o programa que estamos tratando não é uma sobrecarga na concepção formal da apostila. Pergunto: poderiia dar um exemplo simples de sobrecarga de método, baseado no conceito da apostiila ?

    Por falar na apostila, onde posso baixa -la ?

    Obrigado

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • :)

    Ok, o tópico foi aberto como sobrecarga de método, mas para não abrir outro tópico, vou usar este para falar sobre sobrecarga de operador. Vi a apostila e outros materiais na Internet. Achei a explicação muito complicada.

    Só entendi, que o único operador que não aceita sobrecarga, é o de resolução de escopo, ou seja, :: , gostaria de saber se você tem algum exemplo simples de sobrecarga

    Obrigado

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Acho que o melhor exemplo de sobrecarga de operador é aquele que está na apostila mesmo. Soma de números complexos.

    No exemplo, o operador + é sobrecarregado com um método para números complexos.

    Então quando somamos (usamos o operador +) ele "chama" o método correspondente ao tipo de soma.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • :(

    Ok. Suponha agora, a fórmula da combinação simples:

    Cn.p = n! / p! (n – p) !

    Eu gostaria de adaptar o método do arranjo abaixo

     
    int calculando::arranjo (int n, int p) //Sobrecarga do método Arranjo
    {
    return arranjo(n)/arranjo(n -p);
    }

    para

     
    int calculando::combinacao (int n, int p)
    {
    return ([COLOR=red] p *([/COLOR]arranjo(n)/arranjo(n -p[COLOR=red])[/COLOR]);
    )

    De modo que eu aproveite o calculo do arranjo para chegar na combinação. Ë claro, que ai não terei mais sobercarga.

    Obrigado

    Editado por joubet

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Crie uma conta ou entre para comentar

    Você precisar ser um membro para fazer um comentário






    Sobre o Clube do Hardware

    No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações 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

    ×