Zwracanie przez funkcję.

Question

Witam. 

Mam za zadanie zrobić dodawanie, odejmowanie, mnożenie i dzielenie przy bardzo dużych liczbach. Na wejściu jest podawane jako ciąg znaków. Więc rozbijam to na dwa stringi. Zrobiłem dodawanie i odejmowanie tak jak się robi to pisemnie. Natomiast w przypadku mnożenia i dzielenia mam problem.Mnożenie i dzielenie to tak naprawdę dodawanie i odejmowanie wiec chciałbym już użyć istniejących funkcji dodawania i odejmowania. Lecz mam problem ze zwracaniem wartości. Aktualnie funkcje są typu void.

 

#include <iostream>
#include <vector>
#include <cstring>


using namespace std;

void dodawanie(string ciag_1, string ciag_2,int dlugosc_c_1, int dlugosc_c_2 );
void odejmowanie(string ciag_1, string ciag_2,int dlugosc_c_1, int dlugosc_c_2);
void mnozenie(string ciag_1, string ciag_2,int dlugosc_c_1, int dlugosc_c_2, string ciag_3 );
inline int max(int a,int b);
inline int min(int a,int b);
void wypisz(int wynik[], int maksimum);
int czy_wieksza(string ciag_1, string ciag_2, int dlugosc_c_1, int dlugosc_c_2);
int dlugosc(int wynik[], int maksimum);

int main()
{
    int n;
    string ciag_cyfr,ciag_1,ciag_2;
    char znak;
    int dlugosc_c_cyfr,dlugosc_c_1,dlugosc_c_2;

    cin>>n;
    for(int i=0; i<n; i++)
    {
        cin>>ciag_cyfr;
        dlugosc_c_cyfr=ciag_cyfr.length();
        for(int k=0; k<dlugosc_c_cyfr; k++)
        {
            if(ciag_cyfr[k]==42 || ciag_cyfr[k]==43 || ciag_cyfr[k]==45 || ciag_cyfr[k]==47)
            {
                znak=ciag_cyfr[k];
                ciag_1=ciag_cyfr.substr(0,k);
                ciag_2=ciag_cyfr.substr(k+1,dlugosc_c_cyfr-1);
            }
        }

        dlugosc_c_1=ciag_1.length();
        dlugosc_c_2=ciag_2.length();

        //dodawanie(ciag_1,ciag_2,dlugosc_c_1,dlugosc_c_2 );
        odejmowanie(ciag_1,ciag_2,dlugosc_c_1,dlugosc_c_2 );

       // mnozenie(ciag_1,ciag_1,dlugosc_c_1,dlugosc_c_2,ciag_2 );



    }

    return 0;
}

void mnozenie(string ciag_1, string ciag_2,int dlugosc_c_1, int dlugosc_c_2, string ciag_3 )
{

}



void odejmowanie(string ciag_1, string ciag_2,int dlugosc_c_1, int dlugosc_c_2)
{
    int maksimum,minimum,w,wynik[1002];
    maksimum=max(dlugosc_c_1,dlugosc_c_2);
    minimum=min(dlugosc_c_1,dlugosc_c_2);

    if(ciag_1==ciag_2) cout<<"0"<<endl;
    else if(dlugosc_c_1>dlugosc_c_2 || czy_wieksza(ciag_1,ciag_2,dlugosc_c_1,dlugosc_c_2)==1 )
    {
        for(int i=maksimum-1; i>=0; i--)
        {
            if(minimum!=0)
            {
                minimum--;
                if((int)ciag_1[i]>=(int)ciag_2[minimum])
                {
                    w=(int)ciag_1[i]-(int)ciag_2[minimum];
                    wynik[i]=w;
                }
                else
                {
                    int licznik=0,k=i;
                    if(ciag_1[i-1]==48)
                    {
                        do
                        {
                            if(ciag_1[k-1]==48)
                            {
                                licznik++;
                            }
                            k--;
                        }
                        while(ciag_1[k-1]==48);
                        ciag_1[dlugosc_c_1-2-licznik]--;
                        int h=licznik;
                        for(int m=licznik; m>=1; m--)
                        {
                            ciag_1[dlugosc_c_1-1-h]+=9;
                            h--;
                        }
                        w=(int)ciag_1[i]-(int)ciag_2[minimum]+10;
                        wynik[i]=w;
                    }
                    else
                    {
                        ciag_1[i-1]--;
                        w=(int)ciag_1[i]-(int)ciag_2[minimum]+10;
                        wynik[i]=w;
                    }
                }
            }
            else
            {
                wynik[i]=ciag_1[i]-48;
            }
        }
        wypisz(wynik,maksimum);
    }
    else
    {
        for(int i=maksimum-1; i>=0; i--)
        {
            if(minimum!=0)
            {
                minimum--;
                if((int)ciag_2[i]>=(int)ciag_1[minimum])
                {
                    w=(int)ciag_2[i]-(int)ciag_1[minimum];
                    wynik[i]=w;
                }
                else
                {
                    int licznik=0,k=i;
                    if(ciag_2[i-1]==48)
                    {
                        do
                        {
                            if(ciag_2[k-1]==48)
                            {
                                licznik++;
                            }
                            k--;
                        }
                        while(ciag_2[k-1]==48);
                        ciag_2[dlugosc_c_2-2-licznik]--;
                        int h=licznik;
                        for(int m=licznik; m>=1; m--)
                        {
                            ciag_2[dlugosc_c_2-1-h]+=9;
                            h--;
                        }

                        w=(int)ciag_2[i]-(int)ciag_1[minimum]+10;
                        wynik[i]=w;
                    }
                    else
                        ciag_2[i-1]--;
                    w=(int)ciag_2[i]-(int)ciag_1[minimum]+10;
                    wynik[i]=w;
                }
            }
            else
            {
                wynik[i]=ciag_2[i]-48;
            }
        }
        cout<<"-";
        wypisz(wynik,maksimum);
    }
}

void dodawanie(string ciag_1, string ciag_2,int dlugosc_c_1, int dlugosc_c_2 )
{
    int maksimum,minimum,w,wynik[1002];
    maksimum=max(dlugosc_c_1,dlugosc_c_2);
    minimum=min(dlugosc_c_1,dlugosc_c_2);
    int przeniesienie=0;

    for(int i=maksimum-1; i>=0; i--)
    {
        if(dlugosc_c_1>=dlugosc_c_2)
        {
            if(minimum!=0)
            {
                minimum--;
                w=(int)ciag_1[i]+(int)ciag_2[minimum]-96+przeniesienie;
                wynik[i]=w%10;
                przeniesienie=w/10;
            }
            else
            {
                w=(int)ciag_1[i]-48+przeniesienie;
                wynik[i]=w%10;
                przeniesienie=w/10;
            }
        }
        else
        {
            if(minimum!=0)
            {
                minimum--;
                w=(int)ciag_2[i]+(int)ciag_1[minimum]-96+przeniesienie;
                wynik[i]=w%10;
                przeniesienie=w/10;
            }
            else
            {
                w=(int)ciag_2[i]-48+przeniesienie;
                wynik[i]=w%10;
                przeniesienie=w/10;
            }
        }
    }
    if(przeniesienie)
        cout<<1;

    wypisz(wynik,maksimum);
}

int czy_wieksza(string ciag_1, string ciag_2, int dlugosc_c_1, int dlugosc_c_2)
{
    int stan=0;
    if(dlugosc_c_1>dlugosc_c_2) return 1;
    else if(dlugosc_c_1<dlugosc_c_2) return 0;
    else
    {
        for(int i=0; i<dlugosc_c_1 ; i++)
        {
            if(ciag_1[i]<ciag_2[i]) return 0;
            else stan=1;
        }
    }
    if(stan==1) return 1;
}

int dlugosc(int wynik[], int maksimum)
{
    int licznik=0;
    for(int i=0; i<maksimum; i++)
    {
        if(wynik[i]==0) ;
        else
        {
            int l=i;
            for(int k=l; k<maksimum; k++)
            {
                licznik++;
                i=maksimum;
            }
        }
    }

    return licznik;;
}

void wypisz(int wynik[], int maksimum)
{
    for(int i=0; i<maksimum; i++)
    {
        if(wynik[i]==0) ;
        else
        {
            int l=i;
            for(int k=l; k<maksimum; k++)
            {
                cout<<wynik[k];
                i=maksimum;
            }
        }
    }

    cout<<endl;
}

inline int max(int a,int b)
{
    if(a>b)
        return a;
    return b;
}

inline int min(int a,int b)
{
    if(a<b)
        return a;
    return b;
}

 

Answer 1

Nie potrzebujesz przekazywać informacji o długości łańcuchów w parametrach - klasa std::string wie, jak długi łańcuch przechowuje.

Zwracanie wartości typu łańcuchowego realizujesz bardzo prosto - tak samo jak typu liczbowego:

#include <string>

std::string function(const std::string &parameter)
{
    std::string result = parameter + " bar";
    auto length = parameter.length();
    // ...
    return result;
}

// ...

int main()
{
    std::string s = function("foo");
}

 

Comments

Wyniki działań zapisuje w tablicy int wynik[1002], mam problem przy jakby odbiorze tej tablicy. Gdy funkcja zwróci tablicę jak mam ją przypisać do innej tablicy?, albo wypisać na ekran? Czy bez wskaźników w tym wypadku się obędzie, bo przyznam, że nie ogarniam ich za bardzo.

---

A jaki jest powód nadania tablicy wynik rozmiaru akurat 1002?

Nie zapisuj do "surowej tablicy" (raw array), tylko do std::vector. Obiekt std::vector można ładnie i intuicyjnie zwrócić z funkcji dokładnie tak samo jak std::string.

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

auto function(const std::string &parameter1, const std::string &parameter2)
{
    std::vector<int> result;
    result.push_back(std::stoi(parameter1));
    result.push_back(std::stoi(parameter2));
    return result;
}

int main()
{
    std::vector<int> tab = function("123", "456"); 
    // lub:
    // auto tab = function("123", "456");
    
    for(auto i : tab)
    {
        std::cout<<i<<" ";
    }
}

 

---

Dobrze przerobiłem na próbę funkcję dodawania z użyciem wektora i zdaje się, że wszystko działa. Mam jedno pytanie czy wektor znajduje się w standardowych bibliotekach c++., ponieważ wykładowca zabronił korzystać z zewnętrznych bibliotek (np. crt, graph),

---

Tak, std::vector jest elementem biblioteki standardowej C++.