Forum Pasja Informatyki - Najnowsze z tagiem przeciazanie

Przeciążanie operatorów w klasie

Mon, 23 Sep 2024 10:48:46 +0000

Witam,

zacząłem się bawić w klasy w C++. W ramach treningu napisałem swój wektor. Chciałem przeciążyć operator[] w taki sposób, żebym mógł pisać np.

vec[i]=vec[i-1]+3

Dotychczas zwracałem wartość tablicy w indeksie i, ale w takim wypadku nie działa przypisanie do indeksu. Nie wiem jak zrobić by raz vec[i] dawało element jaki przechowuje wektor, a raz wskaźnik na element by można było przypisać wartość.

W skrócie, mój kod wygląda tak:

template <typename Typ> class Wektor
{
    Typ *content;  //zawartosc
    int capacity;  //maksymalna pojemnosc
    int current;  //indeks ostatniej komorki+1

public:
    Wektor();
    ~Wektor();
    Typ get(int index);  //zwraca content[index]
    void push_back(int val);
    
    Wektor& operator=(Wektor& other);  //i to dziala jak powinno

    Typ operator[](int i)
    {
        if(i>=size())  //jesli jest ponad zakresem to blad
            exit(0);
        return get(i);  //zwroc wartosc
    }
}

Z góry dzięki za pomoc.

Przeciążanie operatorów C++

Mon, 20 Feb 2023 19:50:00 +0000

Siema, mam do Was pytanko odnośnie przeciążania operatorów w C++. Mianowicie załóżmy, że mam strukturę jakichśtam obiektów. Niech to będzie struktura Punkt2D przechowująca dwie zmienne: zmienną X oraz Y kartezjańskiego układu współrzędnych. Mam je teraz posortować względem odległości od punktu S(0, 0), a gdy dwa punkty są jednakowo oddalone od punktu S, sortujemy względem zmiennej X rosnąco.

struct Punkt2D {
    int X, Y;
    double R;
};

No i wszystko gra, tylko, że do tej pory robiłem to tak (sortowanie):

tworzyłem pomocniczą funkcję typu bool, która posłuży jako argument metody std::sort()
wywoływałem metodę std::sort() z moją pomocniczą funkcją typu bool

Wygląda to mniej więcej tak:

#include <iostream>
#include <algorithm>

#define N 3

struct Punkt2D {
	int X, Y, R;
	// R - odleglosc od pkt S(0, 0)
};

bool cmp(Punkt2D &a, Punkt2D &b) {
	if (a.R == b.R)
		return (a.X < b.X);
	return (a.R < b.R);
}

int main() {
	Punkt2D tab[] = {{3, 4, 5},
					{4, 3, 5},
					{5, 12, 13}};

	std::sort(tab, tab + N, cmp);
	return 0;
}

Czasem jednak mam dosyć linii kodu, żeby się zgubić i mam pytanie: jak (bo wiem, że się jakoś da, tylko nie wiem jak) zrobić, żeby niejako nie trzeba było tworzyć funkcji cmp()? Wiem, że jakoś da się przeciążać operatory, ale chciałbym nauczyć się konkretnie na tym przykładzie, bo na internecie podają np. jak przeciążyć operator dodawania, tutaj to jest bezużyteczne.

Dzięki z góry za poświęcony czas i nadsyłane komentarze i odpowiedzi :D

Przeciążanie [] tak, aby arr1D[][] było możliwe

Fri, 30 Dec 2022 13:57:51 +0000

Dzień dobry,

starałem się cel ująć w tytule, niemniej należy tutaj dokładnie opisać, że mam na myśli rzecz następującą:

Mam (dynamiczną) tablicę jednowymiarową i chcę traktować ją jako dwuwymiarową, zatem chciałbym móc na niej używać podwójnego operatora "[]", gdzie pierwszy naturalnie wskazywałby wiersz, a drugi kolumnę.

Doszedłem do tego:

#include <iostream>
using namespace std;


class Matrix
{
    friend class MatrixRow;


private:
    double* matrix;
    unsigned rows;
    unsigned columns;

    unsigned rowIdx=0;


    class MatrixRow
	{
	    friend class Matrix;

    private:
		double operator[](unsigned i)
		{
			return Matrix::matrix[Matrix::rowIdx+i];
		}
	};


public:
	Matrix(unsigned rows, unsigned columns)
	{
	    this->rows=rows;
	    this->columns=columns;
	    matrix=new double[rows*columns];

	    for(unsigned i=0; i<rows*columns; i++)
        {
            matrix[i]=static_cast<double>(i)+0.1;
        }
	}

	void operator[](unsigned i) const
    {
        rowIdx=i;
        MatrixRow::operator[]()
    }

	void operator=(double* matrix)
	{
		this->matrix=matrix;
	}
};



int main()
{
	Matrix matrix(3, 4);

	cout << matrix[2][3];

    return 0;
}

W pierwszym operatorze [], którego przeciążenie obsługuje sama klasa Matrix, muszę przekazać indeks wiersza. Mogę sprawić, że klasa wewnętrzna, MatrixRow, będzie znała ten indeks poprzez zaprzyjaźnienie klas i dodatkowe pole RowIdx. Natomiast nie wiem, co z wywołaniem przeciążenia operatora w klasie MatrixRow. Co ja mam przekazać jako argument? Nie wiem, może już od początku to jest zły.

Proszę o wskazówki.

Przeciążanie operatorów w C++. Co oznacza ta linia?

Thu, 29 Jul 2021 16:59:23 +0000

Witam,
Ostatnio szukam informacji na temat operatorów << i >>. Chodzi o ich używanie poza cout i cin.
Natrafiłem na wpis, że to są normalne operatory, które można sobie dostosować pod funkcję/klasę czy obiekt.
Nie rozumiem za bardzo tego tematu. Czy może ktoś mi to wyjaśnić?

W odpowiedzi na pytanie na StackOverflow (link) jest linia kodu (poniżej podana) gdzie używane są operatory &. O ile jestem w stanie zrozumieć część tego kodu, to nie wiem w jakim kontekście są używane znaki &. Jako wskaźnik czy co?

template<typename T>
std::vector<T> & operator<<(std::vector<T> & v, T const & item)

Przyznam, że temat wektorów mam nieprzepracowany, więc może dlatego nie rozumiem tego. Jeśli ktokolwiek może pokazać przeciążanie operatorów na przykładzie normalnych zmiennych czy klas, to byłbym wdzięczny.
Z góry dziękuję za każdą odpowiedź czy wskazówkę!

Liczby zespolone po obiektowemu -przeciążanie operatorów << i >>

Tue, 19 Jan 2021 16:22:17 +0000

Cześć

Na potrzeby programu muszę w poprawny sposób wypisywać liczby zespolone do czego mam się posłużyć funkcjami zaprzyjaźnionymi przeciążającymi operatory << i >> .

Poniżej podsyłam kod.

Protoyp:

#ifndef COMPLEX_H_
#define COMPLEX_H_

class Complex
{
  private:
    double re, im;
  public:
    Complex(double real = 1.0, double imaginary = 1.0);
    Complex operator+(const Complex obj_temp);
    Complex operator-(const Complex obj_temp);
    Complex operator*(const Complex obj_temp);
    friend Complex operator*(double value, const Complex obj_temp);
    Complex operator~();
    friend std::istream & operator>>(std::istream & is, const Complex & number);
    friend std::ostream & operator<<(std::ostream & is, const Complex & number);
    ~Complex();


};

#endif

Implementacja:

#include <iostream>
#include "complex0.h"


Complex::Complex(double real, double imaginary)
{
  re = real;
  im = imaginary;
}

Complex Complex::operator+(const Complex obj_temp)
{
  Complex temp;
  temp.re = re + obj_temp.re;
  temp.im = im + obj_temp.im;
  return temp;
}

Complex Complex::operator-(const Complex obj_temp)
{
  Complex temp;
  temp.re = re - obj_temp.re;
  temp.im = im - obj_temp.im;
  return temp;
}

Complex Complex::operator*(const Complex obj_temp)
{
  Complex temp;
  temp.re = (re * obj_temp.re) - (im * obj_temp.im);
  temp.im - (re * obj_temp.im) + (im * obj_temp.re);
  return temp;
}

Complex operator*(double value, const Complex obj_temp)
{
  Complex temp;
  temp.re = value * obj_temp.re;
  temp.im = value * obj_temp.im;
  return temp;
}

Complex Complex::operator~()
{
  im = -im;
}

std::istream & operator>>(std::istream & is, const Complex & number)
{
  using std::endl;
  using std::cout;
  cout << "Skladowa rzeczywista: ";
  while( !(is >> number.re) )
  {
    is.clear();
    while( is.get() != '\n' )
      continue;
    cout << "ERROR! Try again!" << endl;
    cout << "Skladowa rzeczywista: ";
  }

  std::cout << "Skladowa urojona: ";
  while( !(is >> number.im) )
  {
    is.clear();
    while( is.get() != '\n' )
      continue;
    cout << "ERROR! Try again!" << endl;
    cout << "Skladowa urojona: ";
  }
  return is;
}

std::ostream & operator<<(std::ostream & os, const Complex & number)
{
  using std::cout;
  using std::endl;
  os << "(" << number.re << ", " << number.im << "i)" << endl;
  return os;
}
Complex::~Complex()
{

}

main.cpp

#include <iostream>
#include "complex0.h"

int main()
{
  using namespace std;
  Complex a(3.0, 4.0);
  Complex c;
  cout << "Podaj liczbe zespolona (k, ab zakonczyc):\n";
  cin >> c;
  cout << "c to " << c << '\n';
  cout << "Sprzezona z c to " << ~c << '\n';
  cout << "a to " << a << '\n';
  cout << "a + c wynosi " << a + c << '\n';
  cout << "a - c wynosi " << a - c << '\n';
  cout << "a * c wynosi " << a * c << '\n';
  cout << "2 * c wynosi " << 2 * c << '\n';
  cout << "KONIEC";
  return 0;
}

Po skompilowaniu i odpaleniu powstaje nieskończona pętla, która cały czas powtarza komunikat "składowa rzeczywista". Tak więc problem najpewniej tkwi w mojej imlementacji obydwu funkcji zaprzyjaźnionych.

Z góry dziękuję za odpowiedzi. :)

Nauka przeciążenia operatorów na przykładzie dodawania współrzędnych punktów.

Sun, 22 Nov 2020 15:50:44 +0000

Cześć :)

Uczę się właśnie przeciążenia operatorów i moim pierwszym mini zadankiem w celu przećwiczenia tego jest deklaracja dwóch punktów, a następnie utworzenia 3, który za pomocą przeciążenia operatora + załatwi całą sprawę dodawania współrzędnych.

Wzorowałem się na treści z tego filmu:

https://www.youtube.com/watch?v=N0R4rjUciuo

A oto i mój kod (praktycznie bez różnic):

main.cpp

#include <iostream>
#include "punkt.h"
using namespace std;

int main()
{
    Punkt X(5, 3);
    Punkt Y(2, 1);
    Punkt Z;
    Z = X + Y;
    return 0;
}

punkt.h

#include <iostream>
using namespace std;

class Punkt
{
private:
    int x, y;
public:
    Punkt(int a = 1, int b = 1);
    void read_object();
    friend Punkt  operator+ (Punkt& object);
};

punkt.cpp

#include <iostream>
#include "punkt.h"
using namespace std;

Punkt::Punkt(int a, int b)
{
    x = a;
    y = b;

}
void Punkt::read_object()
{
    cout << "X: " << x << " " << "Y: " << y << endl;
}
Punkt operator+ (Punkt& object)
{
    Punkt wynik;
    wynik.x = x + object.x;
    wynik.y = y + object.y;
    return wynik;
}

Odnośnie ostatniej definicji funkcji z przeciążeniem operatorów wydaje mi się, że to powinno być:

Punkt Punkt :: operator+ (Punkt& object)
{
    Punkt wynik;
    wynik.x = x + object.x;
    wynik.y = y + object.y;
    return wynik;
}

, ale wtedy pokazuje mi się praktycznie 2 razy więcej błędów niż mam obecnie.

Podaję jeszcze komunikaty, jakie mi wyskakują odnośnie błędów:

main.cpp

-dwuargumentowy "+":"Punkt" nie definiuje operatora lub konwersji do typu akceptowalnego dla wstępnie zdefiniowanego operatora

punkt.cpp

- "y" to niezadeklarowany identyfikator

- "x" to niezadeklarowany identyfikator

Z góry dziękuję za wszystkie odpowiedzi. :)

Wejście na serwer kiedy jest przeciążony.

Thu, 27 Aug 2020 12:21:41 +0000

Witam.
W sobotę moja kobieta stanie przed wyborem tematu pracy licencjackiej. A serwery jej uczelni zdychają nawet w momencie wystawienia ocen. Gdzieś kiedyś widziałem post, że jakiś chłopak wszedł dziewczynie na serwer mimo tego ,że był on przeciążony. Mam pytanie jak zrobić coś takiego, zależy mi na tym mocno aby jej pomóc.

Dziękuję za wszelkie odpowiedz.

Przeciążenia operatora []

Fri, 15 May 2020 13:21:56 +0000

Jak przeciążyć operator [], żebym mógł używać go do macierzy? Np:

Matrix m(4,4);

cout<<macierz[2][1]<<endl;

Gdzie Matrix to jest klasa

class Matrix
{
public:

    float **tab;
    int x,y;

    Matrix(float** arg_tab, int xx, int yy);
    Matrix(const Matrix &_copy);
    Matrix(int xx, int yy);
    ~Matrix();
};

Konstruktory:

Matrix::Matrix(float** arg_tab, int xx, int yy)
{
    x = xx;
    y = yy;
    tab = new float*[y];
    for(int i=0; i<y; i++)
        tab[i] = new float[x];

    for(int i=0; i<y; i++)
        for(int k=0; k<x; k++)
            tab[i][k] = arg_tab[i][k];
}
Matrix::Matrix(const Matrix &_copy)
{
    x = _copy.x;
    y = _copy.y;
    tab = new float*[y];

    for(int i=0; i<y; i++)
    {
        tab[i] = new float[x];
        for(int k=0; k<x; k++)
            tab[i][k] = _copy.tab[i][k];
    }
}

Matrix::Matrix(int xx=1, int yy=1)
{
    x = xx;
    y = yy;

    tab = new float*[y];

    for(int i=0; i<y; i++)
        tab[i] = new float[x];
}

Przeciążanie operatorów wejścia/wyjścia w języku C++

Sat, 07 Mar 2020 19:26:51 +0000

Siemka, jak przeciążyć operatory wejścia/wyjścia w c++? Nie chodzi mi o przeciążenie w klasie czy coś takiego.

Przeciążanie operatorów a tworzenie obiektu

Sat, 01 Feb 2020 22:22:55 +0000

Cześć, mam problem z tym zadaniem, a mianowicie z przeciążeniem operatorów zaznaczonych pogrubioną kursywą, oraz deklaracją obiektów. Jeżeli mógłby ktoś napisać jak przeciążyć te operatory byłbym wdzięczny

Podaj implementację klasy Samochod, która
w sekcji prywatnej ma pola
- ileSiedzacych - pole stałe o dodatniej wartości całkowitej, określające liczbę miejsc siedzących w samochodzie,
- ileZajetych – pole o zmiennej wartości całkowitej, reprezentujące liczbę miejsc zajętych
oraz w sekcji publicznej
- konstruktor ustawiający wartości pól na podstawie dwóch parametrów o wartościach domyślnych. Wartości
domyślne to 5 w celu ustawienia pola max oraz 0 (zero) dla pola zajete;
- metodę Wolnych dającą w wyniku wywołania liczbę wolnych miejsc siedzących;
- metodę Pasazerow dającą w wyniku wywołania liczbę zajętych miejsc siedzących;
-przeciążony operator += , metoda pozwala na powiększenie liczby zajętych miejsc siedzących o co
najwyżej ustaloną nieujemną liczbę całkowitą, wynikiem metody jest liczba zajętych miejsc siedzących
- przeciążony operator-= , metoda pozwala na zmniejszenie liczby zajętych miejsc siedzących o co
najwyżej ustaloną nieujemną liczbę całkowitą, wynikiem metody jest liczba zajętych miejsc siedzących po
tej operacji

przeciążony operator+= , realizujący przesiadanie z innego samochodu możliwie największej liczby
pasażerów, wynikiem metody jest liczba zajętych miejsc siedzących (pamiętaj o modyfikacji drugiego
samochodu);
-przeciążony operator-= , realizujący przesiadanie do innego samochodu możliwie największej liczby
pasażerów, wynikiem metody jest liczba zajętych miejsc siedzących (pamiętaj o modyfikacji drugiego
samochodu);
Ponadto powinna być możliwość korzystania z operatora << wstawiania do strumienia wyjściowego
informacji o samochodu zawierającej maksymalną liczbę miejsc siedzących i aktualną liczbę miejsc zajętych.
Zadeklaruj
obiekt A45 reprezentujący samochod mający 5 miejsc siedzących w tym 3 zajętych,
obiekt A32 reprezentujący samochodr mający 8 miejsca siedzące w połowie zajęte (zajęte 4),
wskaźnik A51 na dynamicznie utworzony pusty samochod o 5 miejscach siedzących.
Zakładamy, że nie wiemy jakie operacje zostały wykonane na wyżej wymienionych obiektach.
Należy napisać instrukcje pozwalające na
a) przesiadkę wszystkich osób z A45 do A32 i do samochodu wskazywanego przez A51;
b) opuszczenie A32 przez 7 osób;
c) wejście 3 osób do A45 i 4 osób do samochodu wskazywanego przez A51;
d) wyświetlenie liczby pasażerów we wszystkich trzech samochodach razem;
e) wyświetlenie informacji o samochod A32;
f) opuszczenie A32 przez wszystkie znajdujące się w nim osoby;
g) wyświetlenie informacji czy samochod wskazywany przez A51 jest pełny (wszystkie miejsca zajete)

#include <iostream>

using namespace std;

class Samochod
{
private:
    const int  ileSiedzacych;
    int ileZajetych;
public:
    Samochod(int s=5, int z=0);
    int Wolnych();
    int Pasazerow();
    Samochod &operator+=(Samochod k);
    Samochod & operator-=(Samochod k);

};

Samochod &Samochod::operator+=(Samochod k)
{
    ileZajetych+=k.ileZajetych;
    return *this;
}


int Samochod::Pasazerow()
{
    return ileZajetych;
}

int Samochod::Wolnych()
{
    return ileSiedzacych-ileZajetych;
}

Samochod::Samochod(int s, int z):ileSiedzacych(s)
{
    ileZajetych=z;
    if(ileZajetych<0 ||  ileZajetych>ileSiedzacych)
    {
        ileZajetych=0;
    }
}
int main()
{
    
    return 0;
}

Ilość przeciążeń a efektywność

Fri, 16 Aug 2019 01:24:01 +0000

Czy ilość przeciążeń danej funkcji czy operatora wpływa na jego szybkość wywołania?

Python - przeciążanie operatorów

Tue, 09 Jul 2019 20:25:52 +0000

Witam, od niedawna uczę się języka python ( poza C++ ), napisałem prostą testową klasę:

class Point:

    def __init__(self, name, x, y):
        self.name = name
        self.x = x
        self.y = y

    def __str__(self):
        return f"{self.name}({self.x}, {self.y})"

    def __eq__(self, other):
        if self.x == other.x and self.y == other.y:
            return True
        return False

    def __add__(self, other):
        return Point("none", self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Point("none", self.x - other.x, self.y - other.y)

    def multiplication_by_number(self, n):
        return Point(self.name, self.x * n, self.y * n)

Moje pytanie dotyczy przeciążeń metod dla różnych typów, wiem jak np. zrobić metodę która pomnoży przez siebie dwa punkty ( __mult__ ), co jednak jeśli chcę zrobić przeciążenie mnożenia punktu przez liczbę typu float a nie obiektu tej samej klasy? Tzn:

p3 = p3 * 10

bo na razie umiem to zrobić tylko tak:

p3 = p3.multiplication_by_number(10)

w c++ obie metody wyglądały by w ten sposób:

Point operator*(Point p);
Point operator*(int n);

używając C++ mogę zrobić własną metodę czy niezależną funkcję dla każdego typu obiektów... ale w pythonie typy dobierane są automatycznie, czy jest w ogóle możliwość zrobienia czegoś takiego?

Z góry dziękuje za pomoc i pozdrawiam ;)

JAVA- Przeciążanie metod

Mon, 22 Oct 2018 16:05:36 +0000

Witajcie,

mam pytanie odnosnie przeciążania metod w JAVA (w sumie w programowaniu).

Ogólnie to chyba trochę "niebezpieczne", więc ciekawi mnie jak to wyglada w dużych projektach/ programowaniu komercyjnym? Stosuje się standardowo, bez ograniczeń? Ewentualnie kiedy się stosuje, a kiedy nie?

W małych programach pewnie nie zrobi dużej róznicy napisanie nawet 20-stu nowych metod, jednak przy duzym projekcie, gdzie ewentualnie trzeba byłoby stworzyć powiedzmy 1000 (lub więcej- strzelam na ślepo) nowych metod, zamiast przeciążyć istniejące, co z pewnościa odbiloby się na szybkości aplikacji/ programu oraz jej/ jego wielkości.

Ktoś cos poprawi? Wypowie sie? Oczywiście najlepiej doświadczeni programiści z dużą wiedzą.

Jaki jest cel przeciążania metod w Javie?

Sun, 14 Oct 2018 10:33:53 +0000

Jaki jest sens przeciążania metod? Skoro potrzebujemy 'double' to możemy po prostu usunąć linijkę z 'int' i zostawić tylko drugą metodę z 'double'.

public int dodaj (int a, int b) {
      return a+b;
}

public double dodaj (double a, double b) {
      return a+b;
}

Problem z przeciążeniem operatora==, do typu string (C++)

Mon, 17 Sep 2018 15:55:00 +0000

Witam mam taki mam problem z przeciążeniem operatora==(const class &, const class &).
W jednym z programów (wykorzystując typ char), utworzyłem takie oto przeciążenie:

"sign" to składowa klasy, dokładniej

char * sign;

bool operator==(const Magazine & st1, const Magazine & st2)
{ return strcmp(st1.sign, st2.sign) == 0 ); }

W tym momencie chciałem utworzyć odpowiednie przeciążenie dla typu string, który będzie wykonywał dokładnie to samo.

Jakiej funkcji (lub metody kodu) muszę użyć aby osiągnąć taki efekt.

Zaprzyjaźnienie funkcji przeciążającej operator* (C++)

Fri, 03 Aug 2018 21:35:56 +0000

Problem polega na tym, jest niezgodność z zaprzyjaźnioną funkcją operatora*. Funkcja posiada 2 argumenty i definicję. Sprawdzałem wiele artykułów i nie wiem gdzie leży błąd.

plik nagłówkowy:

#ifndef STONEWT_H_
#define STONEWT_H_

#include <iostream> // dla obiektu std::ostream
class Stonewt
{
        private:
                enum {Lbs_per_stn = 14}; //liczba funtów na kamienie
                int stone;               //masa w całych kamieniach
                double  pds_left;        //reszta w funtach
                double pounds;           //masa w funtach
        public:
                //konstruktory
                Stonewt();                       //kontruktor domyśny 
                Stonewt(double lbs);             //konstruktor dla funtów
                Stonewt(int stn, double lbs);    //konstruktor dla kamieni i funtów
                //przeciążenia
                Stonewt operator+(const Stonewt & value) const;          //przeciążenie operatora+ dla...
                Stonewt operator-(const Stonewt & value) const;             //przeciążenie operatora- dla...
                friend Stonewt operator*(double d_value, const Stonewt & value);             //przeciążenie operatora* dla...
                friend std::ostream & operator<<(std::ostream & os, const Stonewt & text); 
};

#endif

deklaracje:

#include "stonewt.h" // zawiera <iostream>

Stonewt::Stonewt() { stone = pounds = pds_left = 0; }
Stonewt::Stonewt(double lbs)
{
        stone = int (lbs) / Lbs_per_stn; //dzielenie całkowite
        pds_left = int (lbs) % Lbs_per_stn + lbs - int (lbs);
        pounds = lbs;
}
Stonewt::Stonewt(int stn, double lbs)
{
        stone = stn;
        pds_left = lbs;
        pounds = stn * Lbs_per_stn + lbs;
}

Stonewt Stonewt::operator+(const Stonewt & value) const { return Stonewt(stone + value.stone, pounds + value.pounds); }

Stonewt Stonewt::operator-(const Stonewt & value) const { return Stonewt(stone - value.stone, pounds - value.pounds); }

Stonewt operator*(double d_value, const Stonewt & value) { return value * d_value; }

std::ostream & operator<<(std::ostream & os, const Stonewt & text)
{
        os << "Masa w kamieniach: " << text.stone << " kamieni, " << text.pds_left << " funtów\n" << "Masa w funtach: " << text.pounds << " funtów\n";
        return os;
}

Proszę o podpowiedź co mogło pójść tutaj nie tak.

Przeciązenie operatorów (C++)

Sat, 28 Jul 2018 15:11:44 +0000

Czy przeciązenie operatów występuję tylko i wyłącznie w programowaniu obiektowym (mam tu na myśli tylko w klasach) ?

Czy jest szansa aby wykorzystać to jako zwykłą funkcje, a nie składową ?

Wywołanie przeciążenia operatora<< (C++)

Mon, 09 Jul 2018 06:51:47 +0000

Witam napisałem program, w którym występują przeciązenia:

Obie występują klasie, ich deklaracja jest poprawna, różnia się wywołaniami

friend std::ostream & operator<<(std::ostream & out, const Wektor & word_out);
friend std::ostream & operator<<(std::ostream & out, double & multi);

Oto wywołania:

operator<<(std::cout, class_object);
 std::cout.operator<<(d_value);

Problem polega na tym, że wywołanie pierwszej funkcji jest całkowicie poprawne, natomiast drugie wyświetla wartość z wyrażenia, jednak nie wyświetla tekstu, ani przeniesienia do nowej linii.

std::ostream & operator<<(std::ostream & out, double & multi)
        {
                Wektor o;
                out << "\nMnożenie: " << o.operator*(multi) << std::endl << std::endl;
                return out;
        }

W jaki sposób mogę sprawić aby działał poprawnie?

Problem z utworzeniem obiektu ostream

Wed, 04 Jul 2018 13:06:50 +0000

Próbowałem wielu sposobów i dodałem wszystko to co powinno być zawarte mimo wszystko, wciąż pokazuje błąd:

#include "out.h"
int main()
{
        Out result("London", 30000);
        std::ostream os;
        operator<<(os, result);
        os << result;
}//main

Dyrektywa #include <iostream>, zawarta jest w pliku nagłówkowym.

In file included from /usr/include/c++/5/iostream:39:0,
                 from out.h:4,
                 from main_out.cpp:1:
/usr/include/c++/5/ostream: In function ‘int main()’:
/usr/include/c++/5/ostream:384:7: error: ‘std::basic_ostream<_CharT, _Traits>::basic_ostream() [with _CharT = char; _Traits = std::char_traits<char>]’ is protected
       basic_ostream()
       ^
main_out.cpp:5:15: error: within this context
  std::ostream os;

Projektowanie klasy abstrakcyjnej, problem z wirtualnym przciążaniem operatora<<

Sun, 03 Jun 2018 14:25:31 +0000

Hej, ćwicząc nowo nabywaną wiedzę zacząłem projektować prostą klasę bazową o nazwie BaseRectangle, z niej dziedziczy klasa opisująca kwadrat oraz opisująca prostokąt. Dla klas potomnych chciałem przeciążyć operator<<

( jego definicja wygląda inaczej dla dwóch klas dziedziczących ), problem jest jednak taki że podany operator nie powinna przeciążać metoda lecz zwykła funkcja z pierwszy argumentem jako referencja na obiekt klasy std::ostream a z drugim jako np. stała referencja na nasz obiekt. Wobec tego funkcja operatora<< wywołuje odpowiednią metodę wirtualną ( przeciążającą << ) w zależności od podanego w argumencie obiektu dziedziczącego po BaseRectangle. Wszystko wygląda tak:

#include <iostream>
#include <string>

class BaseRectangle;
std::ostream& operator<<(std::ostream&, const BaseRectangle&); //drugi parametr to 
//referencja typu klasy abstrakcyjnej

///---------------------------------------------------------------------------------------

class BaseRectangle { //klasa abstrakcyjna
	friend std::ostream& operator<<(std::ostream&, const BaseRectangle&);
public:
	struct Coords { int x; int y; };
private:
	Coords pos;
public:

	BaseRectangle(int pos_x=0, int pos_y=0) : pos{ pos_x,pos_y } {}

	Coords& returnPos() {
		return pos;
	}

	Coords returnPos() const {
		return pos;
	}

	void move(int x, int y) {
		pos = { x,y };
	}

	virtual long area() = 0;

protected:
	virtual std::ostream& operator<<(std::ostream& os) const = 0; //by klasy potomne wiedzialy o istnieniu tej metody i mogły mieć jej 
//własną definicje ale by reszta programu nie miała do tej metody dostępu 

};

///---------------------------------------------------------------------------------------

class Rectangle : public BaseRectangle { //prostokąt 

	friend std::ostream& operator<<(std::ostream&, const BaseRectangle&);

	virtual std::ostream& operator<<(std::ostream& os) const { //prywatna sekcja by nie moc stosować zapisu w stylu: 
//Rectangle << cout; ( z tej metody korzysta funkcja zaprzyjaźniona )
		os << "width = " << width << ", height = " << height << std::endl;
		os << "pos(x,y) = ( " << returnPos().x << ", " << returnPos().y << " )\n";
		return os;
	}

private:
	int width;
	int height;
public:
	Rectangle(int w=0, int h=0, int x=0, int y=0) : BaseRectangle(x,y), width(w), height(h) {}

	virtual long area() {
		return width*height;
	}
};

///---------------------------------------------------------------------------------------

class Square : public BaseRectangle { //kwadrat

	friend std::ostream& operator<<(std::ostream&, const BaseRectangle&);

	virtual std::ostream& operator<<(std::ostream& os) const { //taka sama sytuacja
		os << "dimension = " << dimension << std::endl;
		os << "pos(x,y) = ( " << returnPos().x << ", " << returnPos().y << " )\n";
		return os;
	}

private:
	int dimension;
public:

	Square(int d=0, int x=0, int y=0) : BaseRectangle(x, y), dimension(d) {}

	virtual long area() {
		return dimension*dimension;
	}

};

///---------------------------------------------------------------------------------------

std::ostream& operator<<(std::ostream& os, const BaseRectangle& bs) {
	bs << os; //wywołanie prywatnej metody 
//operatora<< w zależności od podanego argumentu
	return os;
}

Błędy kompilacji jaki mam:

Jestem w temacie dziedziczenia jeszcze bardzo zielony, trochę tu nakombinowałem i musiałem coś zawalić, wiecie może co? Czy w ogóle dobrze myślałem/kombinowałem nad sposobem rozwiązania tego problemu?

Z góry bardzo wam dziękuje za pomoc ;)

Przeciążanie operatorów

Sun, 27 May 2018 12:22:15 +0000

Witam,

mam problem z operatorem ">>" i "<<". Mianowicie podczas tworzenia klasy przy kompilacji otrzymuje błędy:
Error C2679 binary '<<': no operator found which takes a right-hand operand of type 'std::string' (or there is no acceptable conversion) oraz
Error (active) E0349 no operator "<<" matches these operands

Otworzyłem kody błędów w przeglądarce i wyczytałem coś o przeciążaniu operatorów ale nie wiem jak to zrobić. Można chyba skorzystać z funkcji operator ale nie wiem jak jej użyć, zresztą nie powinna być ona potrzebna do stworzenia programu. Chciałbym żeby ktoś przybliżył mi na czym polega błąd i wyjaśnił całe to przeciążanie jeśli o tym mowa. Pozdrawiam

void daj_glos()
	{
		if (gatunek == "kot") cout << imie << " lat" << wiek << ": miau";
		else if (gatunek == "koza")  cout << imie << " lat" << wiek << ": meee";
		else if (gatunek == "krowa")  cout << imie << " lat" << wiek << ": muuu";
		else cout << "Nieznany gatunek";
	}

Przeciążanie operatora >> i << dla listy

Thu, 19 Apr 2018 16:17:26 +0000

Cześć,

Tak jak w temacie... Operator wyjścia chyba jest dla mnie jasny, bo ma za zadanie wypisanie tego, co znajduje się wewnątrz listy, czyli mógłbym tam umieścić funkcję printList(), której kod poniżej? A co z operatorem wejścia? Nie bardzo wiem, co taki operator ma robić, skoro mam metodę addFirstNode - która dodaje element do listy. Mógłby ktoś podpowiedzieć w tej sprawie?

    void printlist(){
        Node *tmp = new Node;
        tmp = head;
        while(tmp != NULL){
            cout << tmp->data << "\t";
            tmp = tmp->next;
        }
    }

    void addFirstNode(int value){
        Node *tmp = new Node;
        tmp->data = value;
        tmp->next = head;
        head = tmp;
    }

przeciążanie funkcji w c++ - pytanie

Tue, 06 Mar 2018 19:49:08 +0000

Witam, mam takie proste i śmieszne funkcje:

void show(int a) {
	std::cout << a << std::endl;
}

void show(double a) {
    std::cout << a << std::endl;
}

void show(char str[]) {
	std::cout << str << std::endl;
}

W zależności od argumentów wywołamy funkcje o odpowiedniej sygnaturze. Albo dla parametru char[], double a czy int a (wiem że może to wszystko nie ma większego sensu ale chce zademonstrować o co mi chodzi). Wywołajmy ją tak:

long int x = 10;
show(x);

//taki sam efekt da:

show(10l); 

//funkcja wywoła się dla parametru typu int

To że tu mamy long int a nie int w niczym nie przeszkadza. W sumie nie trudno się domyślić że w argumencie podajemy wartość różną od double oraz char* . Dlaczego zatem:

unsigned int x = 10; 

show(x); 

//oraz 

show(10u);

to wywołanie powoduje już błąd że wiele funkcji przeciążonych jest zgodnych z listą argumentów?

Dlaczego dla typu long int kompilator mógł się zdecydować a dla unsigned int już nie?

Podawałem też w argumentach typy short. long long i nie było żadnego problemu...

Serdecznie dziękuje za wytłumaczenie ;)

Przeciążanie operatora ostream dla klasy szablonowej

Mon, 22 Jan 2018 12:07:04 +0000

Jestem w trakcie tworzenia projektu w którym mam do wykonania klasę szablonową opartą na kontenerze Vector, oraz dwie klasy: bazową i dziedziczącą po niej klasę pomocniczą. Klasa A (bazowa) 3 stringi tak samo jak klasa pomocnicza B (w taki sposób że przy wywołaniu klasy B wyświetla się 6 stringów).

Klasa A:

class A 
{
protected:
	string jedenA, dwaA, trzyA;
public:
	A(string jeden, string dwa, string trzy);
	A(){}
	virtual void show(ostream& os) const
	{
		os << jedenA << " " << dwaA << " | " << trzyA << endl;
	}
};

Klasa B:

class B : public A{
	string jedenB, dwaB, trzyB;
public:
	B(string mdwa, string mjeden, string zero, string jeden, string dwa, string trzy);
	void show(ostream& os) const
	{
		os << A::jedenA <<" "<< A::dwaA << " | " << A::trzyA << " " << jedenB << " " << dwaB << " " << trzyB << endl;
	}};

Klasa Kontener jest klasą szablonową i zawiera metodę dodaj (dodaje obiekt A lub B do vectora) oraz przeciążony operator ostream:

template <typename T>
class Kontener
{
	vector<T> pojemnik;
public:
	void dodaj(const T AlubB) {pojemnik.push_back(AlubB);};
	friend ostream& operator<<(ostream& os, const Kontener<T>& k)
	{
        for (int i = 0; i < k.pojemnik.size(); ++i)
		{
               os << k.pojemnik[i]; 
        }
	return os; 
    }
};

W programie głównym utworzyłem zmienną typu Kontener<A*> żeby umożliwić dodawanie do vectora obiektów A lub B. W skrócie wygląda to w ten sposób:

int main()
{
	Kontener<A*> kont;
    kont.dodaj(new A(str1, str2, str3));
	kont.dodaj(new B(str1, str2, str3, str4, str5, str6));

    cout << kont <<endl;
    return 0;
}

Problem jest z operatorem. Mianowicie nie wyświetla on wartości ukrytych pod wskaźnikiem tylko adresy wskaźników. W jaki sposób zmienić operator ostream z klasy Kontener (bo podejrzewam że w tym miejscu siedzi problem) tak żeby wyświetlały si wartości? Czy jest możliwość dostania się do metody show z klasy A i B w tym operatorze ostream?

przeciążanie operatora

Wed, 13 Dec 2017 19:38:38 +0000

Stworzyłam częściowe rozwiązania jednak nie do końca potrafię połączyć to w całość. Dziękuje za pomoc.

int main()
{
    const x = 5;

    int tablicaA[ 5 ];
    for( int i = 0; i < 5; i++ )
    {
        cout << "element " <<( i + 1 ) << ": ";
        cin >> tablicaA[ i ];
    }
    for( int i = 0; i < 5; i++ )
    {
        cout << "element tablicy " << tablicaA[ i ] << endl;
    }
    int tablicaB[ 4 ];
    for( int i = 0; i < 4; i++ )
    {
        cout << "element " <<( i + 1 ) << ": ";
        cin >> tablicaB[ i ];
    }
    for( int i = 0; i < 4; i++ )
    {
        cout << "element tablicy " << tablicaB[ i ] << endl;
    }
    int suma[ 4 ];
    for( int i = 0; i < 4; i++ )
    {
        suma[ i ] = tablicaA[ i ] + tablicaB[ i ];
        cout << "suma elementu tablicy " <<( i + 1 ) << " wynosi: " << suma[ i ] << endl;
    }
    getch();
    return 0;
}

void Odejmijx(){
    for(int i = 0; i < n; ++i) {
      tab[i] = i - x;
      cout << tab[i] << endl;
    }
}

void Odejmij1(){
    for(int i = 0; i < n; ++i) {
      tab[i] = i - 1;
      cout << tab[i] << endl;
    }
}

void Dodajx(){
    for(int i = 0; i < n; ++i) {
      tab[i] = i + x;
      cout << tab[i] << endl;
    }
}

void Dodajx(){
    for(int i = 0; i < n; ++i) {
      tab[i] = i + 1;
      cout << tab[i] << endl;
    }
}


void Dodajx(){
    for(int i = 0; i < n; ++i) {
      tab[i] = i + 1;
      cout << tab[i] << endl;
    }
}
//operator zwraca tablicę jak przed wykonaniem dodawania
void Dodaj1a++(){
    for(int i = 0; i < n; ++i) {
      tab[i] = i++;
      cout << tab[i] << endl;
    }
}

class tablica{
    public:
//f. alokuj¹ca pamieæ dla tabl. Jednowymiarow¹ int
int* tablica(int r);
//f. wype³niajaca tabliê
void fibo(int *t, int r);
// f. drukuj¹ca tablicê jednowymiarow¹ int na ekran
void  druk(int *t, int r);

void Print();

void Odejmijx();

void Odejmij1();

void Dodajx();

void Dodaj1();

void Dodaja++();

void Dodaja--();
    private:
        
};

Zdefiniowałam klasę w której są deklarację funkcji, czy powinnam coś umieścić w sekcji private?

Jak zdefiniować tablicę A i B a póżniej tylko na nich działać poprzeż dodawanie 1 lub x, itd.

niejednoznaczna przeciążona funkcja z szablonami

Tue, 10 Oct 2017 18:32:57 +0000

Witam, jak mogę przerobić którąś z deklaracji, aby zawsze gdy podam NotAlwaysCountable wywoływała się pierwsza funkcja?

template<typename ReturnType, typename Type, typename... Args>
ReturnType average(const NotAlwaysCountable<Type> &value, Args... nextArgs);

template<typename ReturnType, typename Type, typename... Args>
ReturnType average(const Type &value, Args... nextArgs);

Przeciążanie operatora >>

Sat, 10 Jun 2017 14:26:05 +0000

    istream& operator>>(istream &input ,Game &Match)
    {
        cout<<"dzialam";
        input.clear();
        input.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        input>>Match.pick;
        return input;
    }

Chcę przeciążyć operator wejścia w taki sposób żeby za każdym razem czyściło mi jego zawartość przed jego użyciem. Czy ten kod jest poprawnie napisany? Kod się kompiluje ale nie zauważyłem jego obecności w kodzie :/

Game u mnie to klasa w której chce przeciążyć operator a Match to jej obiekt

Przeciążanie operatora jednoargumentowego

Mon, 22 May 2017 15:18:06 +0000

Witam,

Mam pewien problem ze zrozumieniem pewniej rzeczy. Otóż przeciążyłem argument jednoargumentowy:

Zespolona operator- ();

Zespolona Zespolona::operator- ()
{
	return Zespolona(-this->re, -this->im);
	
}

I gdy stworzą obiekt z1, a następnie chciałbym zmienić wartość liczby na ujemną tym sposobem nie działa:

//stworzenie obiektu z1;

-z1; 
std::cout  <<  z1;

std::cout << -z1 // <---- tym sposobem dziala

Wydaję mi się, że to przez to iż funkcja nie działa na oryginalnym obiekcie. W jaki sposób można sprawić, że ten sposób zadziała? O ile w ogóle można. :)

Przeciazenia c++

Wed, 12 Apr 2017 07:32:17 +0000

Dzien dobry chcialem zapytac ktore operatory musza byc zapezyjaznione dla przeciazenia

Przeładowanie operatorów c++

Sat, 18 Mar 2017 20:37:29 +0000

Piszę ostatnio klasę z przeciążonym operatorem = i kompilator oddaje błąd "funkcja operator = może miec tylko jeden argument" o co chodzi chyba operator 'równa się' powinien mieć dwa argumenty jeden z przodu drugi z tyłu???

Kiedy nie musimy przeciążać operatora przypisania("=")?

Mon, 06 Mar 2017 18:44:29 +0000

Witam. Kiedy nie musimy przeciążać operatora przypisania("=")?. Wydaje mi się, że wtedy kiedy nie tworzymy obiektów, bo w przypadku przypisania nadpisywany obiekt może mieć jakieś dane (wskaźniki) które trzeba ręcznie posprzątać . Nie jestem pewien czy dobrze myślę. Proszę o pomoc

C++ Przeciążanie funkcji Odczytywania pliku

Wed, 01 Mar 2017 19:18:28 +0000

Chciał bym przeciążyć metodę FileReader tak by wersja z argumentem path działała

Oczywiscie chodzi że kod sie nie kompiluje i nie wiem czemu nie przyjmuje funkcja "reader" w funkcji "FileReader" nie przyjmuje argumentu path i kod sie wywala

#include <iostream>
#include <fstream>
#include <windows.h>

using namespace std;
void FileReaderText(){



}
void FileReader(){
    ifstream reader;
    cout<<"zosta³ wczytany plik"<<endl;
    reader.open("C:/Users\Burdello-BumBum\Desktop\LoremIpsum.txt");
    if(reader.good()){
        cout<<"otworzono plik"<<endl;
    } else {
        cout<<"Nie udalo sie otworzyc pliku"<<endl;
    }
}
void FileReader(string path){

    ifstream reader;
    reader.open(path);

}

int main(char* cos[])
{


    return 0;
}

Przeciążanie operatorów WinApi

Fri, 27 Jan 2017 13:20:10 +0000

Przeciążyłem operator << tak, że jeśli po jego lewej stronie stoi argument typu HWND, a po prawej string to do istniejącego tekstu jest dopisywany ten string. Stworzyłem zatem okienkowy odpowiednik cout żeby ułatwić sobie pracę. Mam w związku z tym kilka pytań

1. W Symfonii C++ jest napisane, że nie można przeciążać operatora dla samych typów wbudowanych, co najmniej jeden argument funkcji operatorowej musi być typu zdefiniowanego przez programistę (BTW czy może to być np. struktura, a nie klasa?). Mój program działa, bo string nie jest typem wbudowanym, ale co gdybym użył zamiast stringa np. int? Wiem, że mógłbym sam sprawdzić, ale chwilowo nie mam dostępu do komputera z projektami i kompilatorem, a bardzo mnie to ciekawi. Czy zmienne z biblioteki WinApi są typami wbudowanymi?

2. Przeciążać nie można podobno dla typów wbudowanych bo definicje takich funkcji operatorowych podobno gdzieś już są (Symfonia wydanie 3 str 712). Ale w przypisie jest napisane, że trochę to tłumaczenie naciągane. O co w tym chodzi? Co gdybym przeładował np. operator * , a funkcja przyjmowała by np. floata i chara? Są wbudowane, ale chyba nie istnieje taka funkcji operatorowa, więc zadziałałoby czy nie i dlaczego? Chcę się trochę więcej dowiedzieć, zanim zacznę pisać własną bibliotekę "winoperators.h".

przeciążone operatory - obiektowy C++

Sun, 04 Dec 2016 14:06:23 +0000

Witam. Mam pytanie co do tego kodu:

#include <iostream>
#include <string>

using namespace std;

class Konto_Bankowe
{
private:
    string nazwa_konta;
    double stan_konta;
public:
    Konto_Bankowe();
    Konto_Bankowe(string nazwa, int hajs);
    ~Konto_Bankowe();
    Konto_Bankowe operator+(const Konto_Bankowe & suma) const; //dodawanie obiekt + obiekt
    friend ostream & operator<<(ostream & os, const Konto_Bankowe & stan);
};

Konto_Bankowe::Konto_Bankowe()
{
    nazwa_konta = "brak nazwy";
    stan_konta = 0;
}

Konto_Bankowe::Konto_Bankowe(string nazwa, int hajs)
{
    nazwa_konta = nazwa;
    stan_konta = hajs;
}

Konto_Bankowe::~Konto_Bankowe()
{
}

Konto_Bankowe Konto_Bankowe::operator+(const Konto_Bankowe & suma) const
{
    Konto_Bankowe sumowanie;
    sumowanie.stan_konta = stan_konta + suma.stan_konta;
    return sumowanie;
}

ostream & operator<<(ostream & os, const Konto_Bankowe & stan)
{
    os << "Nazwa konta: " << stan.nazwa_konta << ", stan tego konta wynosi: " << stan.stan_konta << ".";
    return os;
}

int main()
{
    Konto_Bankowe obiekt1("Wp.pl", 8000);
    Konto_Bankowe obiekt2("Onet.pl", 4000);

    obiekt1 = obiekt1 + obiekt2;

    cout << obiekt1 << endl;

    return 0;
}

Mamy tutaj klasę Konto_Bankowe. W klasie tej korzystamy z dwóch metod przeciążających operatory. W funkcji main najpierw dodajemy dwa obiekty do siebie obiekt1 = obiekt1 + obiekt2; a następnie wyświetlamy nasz wynik dodawania: cout << obiekt1 << endl;. Po skompilowaniu otrzymujemy: Nazwa konta: brak nazwy, stan tego konta wynosi: 12000.

Moje pytanie: Dlaczego wynik dodawania jest wyświetlany poprawnie, wynosi on 12000, zaś nazwa to brak nazwy skoro nazwa dla obiekt1 to Wp.pl? W jaki sposób można sprawić, aby zamiast brak nazwy było napisane Wp.pl?

C++ przeciążanie operatora dodawania dla klasy String.

Sat, 26 Nov 2016 15:03:16 +0000

Hej, mam problem z przeciążeniem operatora dodawania dla własnej klasy String.

class String
{
private:
    char * str;
    int len;
    static int num_strings;
    static const int CINLIM = 80;
public:
    String(const char * s);
    String();
    String(const String &);
    ~String();
    int length () const {return len;}
    String & operator=(const String &);
    String & operator=(const char *);
    char & operator[](int i) const;
    friend bool operator<(const String & st1, const String & st2);
    friend bool operator>(const String & st1, const String & st2);
    friend bool operator==(const String &st1, const String  & st2);
    friend ostream & operator<<(ostream & os, const String & st);
    friend istream & operator>>(istream & is, String & st);
    static int HowMany();
    friend String operator+(const String & st1, const String & st2);
    String & stringlow();
};

Przeciążenie operatora dodawania:

String operator+(const String & st1, const String & st2)
{
    int length = st1.len + st2.len;
    char * str = new char[length + 1];

    for(int i = 0; i < st1.len; i++)
        str[i] = st1.str[i];

    for(int i = st1.len, j = 0; i < length; i++, j++)
        str[i] = st2.str[j];

    String s(str);
    delete [] str;

    return s;
}

Funkcja main:

int main()
{
    String napis1 = "korea";
    String napis2 = "huhuha";
    String napis3 = napis1 + napis2;
    cout << napis1+napis2 << endl;
    cout << napis3 << endl;
    cout << "hmm" + napis1 << endl;

    return 0;
}

Wynik:

W ostatniej linijce powinno być hmmkorea, a jest hmmkoreauha, z czego to wynika? Wewnątrz funkcji używam operatora delete [] str, a mimo to coś jest nie tak.

Przeciążanie operatora

Wed, 20 Jul 2016 14:22:41 +0000

Mam taki kod i nie mogę poradzić sobię z przeciążaniem operatora, pomoże ktoś?

Ostatni podpunkt zadania.

#include <iostream>

using namespace std;

class TKwota{

private:
    unsigned int zlote;
    unsigned int grosze;

public:

    TKwota()
    {
        zlote = 0;
        grosze = 0;
    }
    TKwota(int a, int b)
    {
        if(b>100)
        {
            zlote = a+(b/100);
            grosze = a%100;
        }
        else
        {
            zlote = a;
            grosze = b;
        }
    }
    void Wyswietl()
    {
        cout<<zlote;
        cout<<grosze;
    }
    void Zwieksz(int c, int d)
    {
        zlote = zlote + c;
        grosze = grosze + d;
    }
    
//tutaj przeciazanie

};


int main()
{
    
    return 0;
}

Przeciążanie operatora wejścia

Wed, 08 Jun 2016 10:57:46 +0000

Mam napisać operator, który pobierze 3 liczby w postaci: [c,b,a] np [5.4 , 4, 45.3], kod wygląda tak:

istream & operator >> (istream & we, Trojmian &troj)
{

   if(we.peek() != '[' )
        we.setstate(ios_base::failbit); //reczne psucie operatora
    we >> troj.c_;

    if(we.peek() != ',' )  //sprawdzam czy  znak to ",", ale go nie pobieram
        we.setstate(ios_base::failbit);
    we >> troj.b_;

    if(we.peek() != ',' )
        we.setstate(ios_base::failbit);
    we >> troj.a_;

    if(we.peek() != ']' )
        we.setstate(ios_base::failbit);



    if(!we)
        cerr << "Napotkano blad przy wczytywaniu!" << endl;
    return we;
}

ale to nie działa, nie mam pojęcia dlaczego, co ciekawsze, taki kod działa:

istream & operator >> (istream & we, Trojmian &troj)
{
    we >> troj.c_;

    if(we.peek() != '+' )  //sprawdzam czy  znak to ",", ale go nie pobieram
        we.setstate(ios_base::failbit);
    we >> troj.b_;

    if(we.peek() != '+' )
        we.setstate(ios_base::failbit);
    we >> troj.a_;

    if(we.peek() != ']' )
        we.setstate(ios_base::failbit);



    if(!we)
        cerr << "Napotkano blad przy wczytywaniu!" << endl;
    return we;
}

ale jeśli "+" zamienię na "," to już nie działa.... wie ktoś co tu jest grane???

Z góry dzięki!

Przeciążanie operatorów wyjścia i dodawania (programowanie obiektowe)

Wed, 04 May 2016 12:32:49 +0000

Dzień dobry! Mam do napisania kod w oparciu o programowanie obiektowe, który będzie dokonywał działań dodawania, odejmowania, mnożenia (itp.) na wektorach. Napisałem już zaczątek kodu, tzn. konstruktor, konstruktor kopiujący, destruktor, operator wyjścia, jednak napotkałem problem przy przeciążaniu operatora dodawania.
Proszę o pomoc w wyjaśnieniu co powoduje następujący błąd:

\main.cpp|10|error: no match for 'operator<<' in 'std::operator<< <std::char_traits<char> >((* & operator<<((* & std::operator<< <std::char_traits<char> >((* & operator<<((* & std::cout), (* & v1))), ((const char*)" +  "))), (* & v2))), ((const char*)" = ")) << Wektor::operator+(Wektor&)((* & v2))'|

Kod algebra.h

#ifndef algebra_h
#define algebra_h

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <ctime>

using namespace std;

class Wektor
{
   private:
      int szerokosc;
      int *tablica;

   public:
      Wektor(int);                                  // Konstruktor
      Wektor(Wektor&);                              // Konstruktor kopiujacy
      ~Wektor();                                    // Destruktor
      Wektor& operator= (Wektor&);                  // Przypisywanie
      Wektor operator+ (Wektor&);                   // Dodawanie
      Wektor operator- (Wektor&);                   // Odejmowanie
      Wektor operator* (Wektor&);                   // Mnozenie
      bool operator== (Wektor&);                    // Rownosc
      bool operator!= (Wektor&);                    // Sprzecznosc
      int operator[] (Wektor&);                     // Indeksowanie
      friend ostream& operator<< (ostream&,Wektor&);// Wyswietlanie
      friend istream& operator>> (istream&,Wektor&);// Wczytywanie
      Wektor& operator+= (Wektor&);                 // Zwiększanie
      Wektor& operator-= (Wektor&);                 // Zmniejszanie
      Wektor& operator*= (int);                     // Wielokrotność
};

#endif

Kod algebra.cpp

#include "algebra.h"

Wektor::Wektor(int s)
{
   if(s<1)
   {
      cout << "Nieprawidlowe wartosci wektora ";
      cout << ". Zostanie utworzony wektor zerowy. " << endl;
      szerokosc=0;
      tablica=NULL;
   }
   else
   {
      szerokosc=s;
      tablica=new int[szerokosc];
      for(int i=0;i<szerokosc;i++)
      {
      tablica[i]=(rand()%10)+0;
      }
   }
}

Wektor::Wektor(Wektor& v)
{
   if(v.szerokosc<1)
   {
      cout << "Nieprawidlowe wartosci wektora ";
      cout << ". Zostanie utworzony wektor zerowy. " << endl;
      szerokosc=0;
      tablica=NULL;
   }
   else
   {
      szerokosc=v.szerokosc;
      tablica=new int[szerokosc];
      for(int i=0;i<szerokosc;i++)
      {
      tablica[i]=v.tablica[i];
      }
   }
}

Wektor::~Wektor()
{
   delete [] tablica;
}

Wektor& Wektor::operator= (Wektor& v)
{
   if(this==&v) return *this;
   if(v.szerokosc==0)
   {
      szerokosc=0;
      delete [] tablica;
      tablica=NULL;
   }
   else
   {
      delete [] tablica;
      szerokosc=v.szerokosc;
      tablica=new int[szerokosc];
      for(int i=0;i<szerokosc;i++)
      {
         tablica[i]=v.tablica[i];
      }
   }
   return *this;
}

Wektor Wektor:: operator+ (Wektor& v)
{
   if(v.szerokosc==0) return *this;
   if(szerokosc==0) return v;
   Wektor w(szerokosc);
   if(szerokosc==v.szerokosc)
   {
      for(int i=0;i<szerokosc;i++)
      {
         w.tablica[i]+=tablica[i];
         w.tablica[i]+=v.tablica[i];
      }
   }
   return w;
}

std::ostream& operator << (ostream& wyjscie,Wektor& v)
{
   {
      wyjscie << "[ ";
      for(int i=0;i<v.szerokosc;i++) wyjscie << v.tablica[i] << " ";
      wyjscie << "] ";
   }
   return wyjscie;
}

Kod main.cpp

#include "algebra.h"

int main()
{
   int mnoznik;
   srand(time(NULL));
   Wektor v1(5),v2(5);
   system("cls");
   cout<<"Wektory 5-wymiarowe:"<<'\t'<<v1<<'\t'<<v2<<endl<<endl;
   cout<<v1<<" +  "<<v2<<" = "<<v1+v2<<endl;
   cout<<v1<<" -  "<<v2<<" = "<<endl;
   cout<<v1<<" *  "<<v2<<" = "<<endl;
   cout<<v1<<" == "<<v2<<" = "<<endl;
   cout<<v1<<" != "<<v2<<" = "<<endl;
   cout<<v1<<" += "<<v2<<" = "<<endl;
   cout<<v1<<" -= "<<v2<<" = "<<endl;
   cout<<v1<<" *= "<<v2<<" = "<<endl;
   cout<<v1<<" [] "<<v2<<" = "<<endl;
   cout<<v1<<" <- "<<v2<<" = "; v1=v2; cout<<v1; getchar();
   return 0;
}

Nadpisywanie operatora '+' w klasie ze zmiennymi dynamicznymi

Sat, 30 Apr 2016 12:48:04 +0000

Chcę zrobić klasę przechowującą duże liczby, używam do tego dynamicznej tablicy znaków. Chcę nadpisać operator dodawania ale w destruktorze dealokuje tablicę znaków co powoduje że nie mogę zwrócić zmiennej ze stosu bo jej pamięć zostaje dealokowana a alokowanie jej na stercie tez nie wydaje mi się dobrym pomysłem bo nie wiem jak później miałbym zwolnić jej pamięć. Jak powinienem to zrobić?

Mam taki kod który daje errora o naruszeniu pamięci:

	bigInt(int len, const char* number) {
		this->len = len;
		this->number = new char[len + 1]; // Dla \0 na koncu
		strcpy(this->number, number);
	}
	~bigInt() {
		delete[] number;
	}

	friend bigInt operator+(bigInt left, const bigInt& right) {
                 // obliczenia
                 return left;
        }

Przeciążenie operatorów c++

Sat, 02 Apr 2016 19:19:54 +0000

Witam

Potrzebuje zrobić mnożenie dwóch wektorów. Nie mam pojęcia jak zwrócić nowy wektor. Prosiłbym o pomoc. Mam problem w miejscu:

Wektor Wektor::operator* (Wektor const& a)
{
	return Wektor(this->wektor * a.wektor);
}

Oczywiscie musze zrobic takze mnozenie wektora razy macierz ale najpierw chce zajac sie wektorami.

Z gory dzieki za pomoc

Z góry dzięki.

plik.cpp

#include <iostream>
#include <string>
#include <cstdlib>
#include "macierze_wektory.h"

using namespace std;

void Wektor::Wczytaj_Wektor()
{
	fstream plik;
	plik.open("wektor.txt");
	if (!plik.good())
	{
		cout << "Nie udalo sie otworzyc pliku";
		system("pause");
		exit(0);
	}

	for (int i = 0; i < 4; i++)
		plik >> wektor[i];

	plik.close();
}

void Macierz::Wczytaj_Macierz()
{
	fstream plik;
	plik.open("macierz.txt");
	if (!plik.good())
	{
		cout << "Nie udalo sie otworzyc pliku";
		system("pause");
		exit(0);
	}

	for (int j = 0; j < 4; j++)
	for (int i = 0; i < 4; i++)
		plik >> macierz[i][j];

	plik.close();
}

Wektor Wektor::operator* (Wektor const& a)
{
	return Wektor(this->wektor * a.wektor);
}

plik.h

#include <iostream>
#include <string>
#include <fstream>
#include <cstdlib>

using namespace std;

class Macierz;

class Wektor
{
private:
	double wektor[4];

public:
	Wektor()
	{
		for (int i = 0; i < 4; i++)
			this->wektor[i] = 0;
	}
	void Wczytaj_Wektor();
	Wektor operator*(const Wektor &a);
};

class Macierz
{
private:
	double macierz[4][4];

public:
	Macierz()
	{
		for (int j = 0; j < 4; j++)
			for (int i = 0; i < 4; i++)
				this->macierz[i][j] = 0;
	}
	void Wczytaj_Macierz();
};



main.cpp

#include <iostream>
#include <string>
#include <cstdlib>
#include "macierze_wektory.h"

using namespace std;

int main()
{
	Wektor w1;
	w1.Wczytaj_Wektor();
	Wektor w2;
	w2.Wczytaj_Wektor();
	Wektor w3 = w1*w2;

	system("pause");
	return 0;
}

Przeciążenie operatorów dodawania/odejmowania boków figur

Sun, 20 Mar 2016 16:37:01 +0000

Witam!
Na forum nie znalazłem jednoznacznej odpowiedzi:

Cwiczenie polega na tym aby stworzyć klasę Figura, której parametry to obwód, pole i liczba boków. i ich długość.
Następnie musimy tak przeciążyć operator + i - aby długości odpowiadających boków zostały dodane lub odjęte. Kiedy figury różnią się ilością boków, wtedy bokom bez par przypisujemy 0. Dodakowo musimy stworzyc obiekt koło, oraz kwadrat o długości boku równej ilości stworzonych obiektów.
Problem:
To moje pierwsze przeciążanie operatorów, więc jeszcze nie wiem do końca z czym to sie je. Przy wywołaniu metody getBoki na obiektach, którę mają być sumą lub różnicą dwóch innych figur otrzymuje śmieci.


#include "stdafx.h"
#include <iostream>

using namespace std;

class Figura
{
private:
	int n; // ilosc bokow
	static int licznik_obiektow;
	double *wielokat;
	double pole;
	double obwod;
	bool czy_trojkat;
	bool czy_kolo;
	bool czy_kwadrat;
public:
	Figura(int);
	Figura();
	Figura(double);
	~Figura();
	Figura operator+(const Figura &);
	Figura operator-(const Figura &);
	Figura& operator=(const Figura &);
	void setBoki();
	void getBoki();
};
int Figura::licznik_obiektow = 0;
Figura::Figura(int a)
{
	licznik_obiektow++;
	n = a;
	wielokat = new double[a];
}
Figura::Figura() // konstruktor obiektu kwadrat jednostkowy
{
	licznik_obiektow++;
	n = 4;
	wielokat = new double[4];
	for (int i = 0; i < 4; i++)
	{
		wielokat[i] = licznik_obiektow;
	}
	pole = licznik_obiektow*licznik_obiektow;
	obwod = 4 * licznik_obiektow;
	czy_trojkat = false;
	czy_kwadrat = true;
	czy_kolo = false;
}
Figura::Figura(double r)// konstruktor obiektu kolo
{
	licznik_obiektow++;
	n = NULL;
	wielokat = new double[1];
	wielokat[0] = r;
	pole = (3.14)*r*r;
	obwod = 2 * (3.14)*r;
	czy_trojkat = false;
	czy_kwadrat = false;
	czy_kolo = true;
}
Figura::~Figura() // destruktor;
{
	delete[] wielokat;
	licznik_obiektow--;
}

Figura Figura::operator+(const Figura &f)
{
	int wieksza, mniejsza;
	(wieksza = (n > f.n) ? n : f.n);
	(mniejsza = (n > f.n) ? f.n : n);
	Figura ret(wieksza);
	wielokat = new double[wieksza];
	ret.obwod = 0;
	for (int i = 0; i < mniejsza; i++)
	{
		ret.wielokat[i] = wielokat[i] + f.wielokat[i];
		ret.obwod += ret.wielokat[i];
	}
	for (int i = mniejsza; i < wieksza; i++)
	{
		ret.wielokat[i] = 0;
	}
	return ret;
}

Figura Figura::operator-(const Figura &f)
{
	int wieksza, mniejsza;
	(wieksza = (n > f.n) ? n : f.n);
	(mniejsza = (n > f.n) ? f.n : n);
	Figura ret(wieksza);
	ret.obwod = 0;
	for (int i = 0; i < mniejsza; i++)
	{
		ret.wielokat[i] = wielokat[i] - f.wielokat[i];
		if (ret.wielokat[i] < 0) ret.wielokat[i] *= (-1);
		ret.obwod += wielokat[i];
	}
	for (int i = mniejsza; i < wieksza; i++)
	{
		ret.wielokat[i] = 0;
	}
	return ret;
}
Figura &Figura::operator=(const Figura &f)
{
	if (&f == this) return *this;
	n = f.n;
	wielokat = new double[n];
	for (int i = 0; i < n; i++)
	{
		wielokat[i] = f.wielokat[i];
	}
	pole = f.pole;
	obwod = f.obwod;
	czy_trojkat = f.czy_trojkat;
	czy_kolo = f.czy_kolo;
	czy_kwadrat = f.czy_kwadrat;
	return *this;
}

void Figura::setBoki()
{
	obwod = 0;
	for (int i = 0; i < n; i++)
	{
		cout << "Dlugosc boku " << i + 1 << ": ";
		cin >> wielokat[i];
		obwod += wielokat[i];
	}
	if (n == 3)
	{
		int j;
		double bufor;
		for (int i = 0; i < 3; i++)
		{
			for (j = 0; j < 3; j++)
			{
				if (wielokat[j] > wielokat[i])
				{
					bufor = wielokat[j];
					wielokat[j] = wielokat[i];
					wielokat[i] = bufor;
				}
			}
		}
		if (wielokat[0] + wielokat[1] > wielokat[2])
		{
			czy_trojkat = true;
			double p;
			p = obwod*(0.5);
			pole = sqrt(p*(p - wielokat[0])*(p - wielokat[1])*(p - wielokat[2])); // wzor Herona
		}
		else
		{
			czy_trojkat = false;
			cout << "To nie jest figura!" << endl;
			obwod = 0;
		}
	}
}

void Figura::getBoki()
{
	for (int i = 0; i<n; i++)
	{
		cout << "Bok " << i + 1 << ": " << wielokat[i] << " j" << endl;
	}
	if (obwod) { cout << "Dlugosc wynosi:" << obwod << " j" << endl; }
	else { cout << "Nie ma obwodu!" << endl; }
	if (czy_trojkat == true) { cout << "Pole trojkata: " << pole << " j^2" << endl; }
	if (czy_kolo == true) { cout << "Pole kola: " << pole << " j^2" << endl; }
	if (czy_kwadrat == true) { cout << "Pole kwadratu:" << pole << " j^2" << endl; }
}

int main()
{
	int rozmiar, ilosc_figur;
	double r;
	Figura *figura_nr;
	cout << "Podaj ile katow ma Twoj wielokat: ";
	cin >> rozmiar;

	Figura a(rozmiar);
	cout << endl;
	a.setBoki();
	a.getBoki();
	cout << endl;

	cout << "Podaj promien Twojego kola: ";
	cin >> r;
	cout << "Tworze kolo" << endl;
	Figura kolo(r);
	kolo.getBoki();
	cout << endl;

	cout << "Ile figur chcesz stworzyc ? ";
	cin >> ilosc_figur;
	figura_nr = new Figura[ilosc_figur];
	for (int i = 0; i < ilosc_figur; i++)
	{
		cout << "Tworze figure " << i + 1 << ". " << endl;
	}

	Figura kwadrat;
	cout << endl << "Tworze kwadrat" << endl;
	kwadrat.getBoki();
	cout << endl;

	Figura b = kwadrat + a;
	Figura c = kwadrat - a;

	b.getBoki();
	c.getBoki();
	delete[] figura_nr;
}

Kompilator to odrzuca ale ja bardzo chce miec taki efekt jak to zrobic ?

Fri, 12 Feb 2016 10:38:10 +0000

Czesc, koduje sobie pewna klase w C++, dosyc specyficzna klase chodzi o bazy danych.

Deklaruje sobie strukture w klasie, udalo mi sie zadeklarowac tylko jedna referencje i to chyba dlatego ze referencja ta jest do czystego obiektu.

Wrzucam kod :

struct references_to_Postgre_Objects //l
  {
    connection C; //To nie jest obiekt transakcyjny, on sluzy do zainicjonowania obiektu transakcyjnego W klasy "work".
    connection &C_reference= C;
    //work W(C); //to jest obiekt transakcyjny
    //work &W_reference = W;
    //nontransaction N(C);//to jest obiekt nietransakcyjny
    //nontransaction &N_reference = N;

  };

To co jest zakomentarzowane jest odrzucane przez kompilator, wiem ze tworzenie refencji do prawdopodobnie metody klasy jest niedorzeczne ale kiedy chce zrobic referencje do samego obiektu to przekierowywuje mnie do kodu biblioteki (<pqxx/pqxx>, czyli postgresql dla C++) i zacina mi sie kompilator.

A samego obiektu nie moge zadeklarowac bo dzieje sie to co napisalem powyzej w dokumentacji pisali ze te obiekty trzeba tworzyc w taki wlasnie dziwny sposob.

No dobra chodzi o to ze chcialbym miec referencje do tych obiektow ktore na chwile obecna tworzy sie za pomoca metod. Jezeli ktos wie o co chodzi prosze o pomoc.

PS: Wszystkie te obiekty pochodza od klas z tej biblioteki <pqxx/pqxx>

Pozdrawiam

c++, problem z przeładowaniem operatora <<

Wed, 30 Dec 2015 23:57:03 +0000

Cześć,

Napisałem program (jest to lista jednokierunkowa) który (narazie) tworzy listę 50 obiektów klasy Point (każdy obiekt tej klasy zawiera losową wartość, numer oraz wskaźnik do następnego obiektu) , a następnie wyświetla je w kolejności w jakiej zostały utworzone. Do wyświetlania tych obiektów przeładowałem operator " << ". Program się kompiluje, jednak co ciekawe raz nie działa poprawnie, a po kolejnej kompilacji bez dokonywania żadnych zmian zaczyna działać poprawnie. Czy jest mi w stanie pomóc???

Kod programu:

#include <iostream>
#include <cstdlib>
using namespace std;

class Point
{
	private:
		Point * next;
		int value, number;
	public:
		Point (int);	
	
		void add (Point *); 
		friend bool ifnext (Point *); 
		
		Point * operator ++(); // przechodzenie do następnego
		
		friend ostream & operator << ( ostream &, Point*); //wypisywanie 
};

Point::Point (int i): next(NULL), value(rand()%100), number(i) {}

void Point::add(Point * pointer)
{
	if (next != NULL) next->add(pointer);
	else next=pointer;
}

bool ifnext (Point * pointer)
{
	if (pointer->next == NULL) return 0;
	else return 1;
}

Point * Point::operator ++ ()
{
	return this->next;
}

ostream & operator << (ostream & wypisz, Point * pointer)
{
	return wypisz << pointer->number << "\t" << pointer->value;
}

int main()
{
	Point * pointer, *root;
	for (int i = 0 ; i < 50 ; i++)
	{
		pointer = new Point(i);
		if(!i) root = pointer;
		else root->add(pointer);
	}

	for (Point * i = root ;  ; ++i)
	{
		cout << i ;
		cout << endl;
		if (!ifnext(i)) break;
	}
	return 0;
}

i wygląd ekranu po uruchomieniu:

MacBook-Air-Mikoaj:Documents Mikolaj$ g++ kopia.cpp -o a.out -Wall -pedantic -ansi

MacBook-Air-Mikoaj:Documents Mikolaj$ ./a.out

0 7

32767 2001401600

32767 2001401528

MacBook-Air-Mikoaj:Documents Mikolaj$ g++ kopia.cpp -o a.out -Wall -pedantic -ansi

MacBook-Air-Mikoaj:Documents Mikolaj$ ./a.out

0 7

32767 2001401600

32767 2001401528

MacBook-Air-Mikoaj:Documents Mikolaj$ g++ kopia.cpp -o a.out -Wall -pedantic -ansi

MacBook-Air-Mikoaj:Documents Mikolaj$ ./a.out

0 7

1 49

2 73

3 58

4 30

5 72

6 44

7 78

8 23

9 9

10 40

11 65

12 92

13 42

14 87

15 3

16 27

17 29

18 40

19 12

20 3

21 69

22 9

23 57

24 60

25 33

26 99

27 78

28 16

29 35

30 97

31 26

32 12

33 67

34 10

35 33

36 79

37 49

38 79

39 21

40 67

41 72

42 93

43 36

44 85

45 45

46 28

47 91

48 94

49 57

MacBook-Air-Mikoaj:Documents Mikolaj$

Przeciążenie operatora dodawania w własnej klasie string

Mon, 28 Dec 2015 17:11:22 +0000

Oto kod :

//konstuktory itp pominalem

class String
{
	char * czar;
	int length;
public :
	
	String & operator+(const String & c);
	String & operator+=(const String & c);
      ~String();
String & String::operator+(const String & c)
{
	
	
	length = length + c.length ;
	char * temp = new char[length+1]; 
	strcpy(temp,czar);
	
	strncat(temp, c.czar, c.length ); //3 argument ile znakow skopiowac
	String * p = new String(temp);
	delete[] temp;
	return *p;
}
String & String::operator+=(const String & c)
{
	*this = *this + c;
	return *this; 
}
String::~String()
{
	delete [] czar;
    
}

Nie wiem jak zastapić :

    String * p = new String(temp);

Destruktor raczej go nie usunie, więc co można tutaj zmodyfikować?

Przeciązenie operatora rownania w klasie ala string, po co zwracany *this?

Mon, 21 Dec 2015 16:21:43 +0000

Jest to przykład z ksiązki szkoła programowania VI S.Prata, str 570

Stringbad & Stringbad::operator=(const Stringbad & st)
{
if(this==&st)
       return *this;

delete []str ;
len = st.len ;
str = new char [len+1] ;
std::strcpy(str,st.str);
return *this
}

Nie potrafię zrozumieć co robi ta zwracana wartość *this, skoro len i str już są zamienione, pomoże ktoś ?:D

edit: jest to funkcja przeciążająca operator równania dla 2 wczesniejszych utworzonych obiektow tj:

Stringbad s1, s2 ;

s1 = s2 ;