Eclipse CDT – środowisko C/C++

Krzysiek Wesołowski — Tue, 14 Oct 2008 23:51:04 +0000

Instalacja Eclipse:

Najpierw zainstalujemy środowisko Eclipse CDT, czyli program Eclipse wzbogacony o dodatkowe wtyczki ułatwiające pracę w językach C/C++.

Pobieramy go ze strony:

http://www.eclipse.org/downloads/
wersja: Eclipse IDE for C/C++ Developers

Pobierzesz w ten sposób skompresowana wersje, która najlepiej sobie rozpakować w jakieś nieprzeszkadzające miejsce (przyjąłem ze to C:\Program Files).

Dodatkowo eclipse do działania może wymagać Javy (którą prawdopodobnie już dawno masz ją na swoim komputerze, jeśli nie, pobierzesz ją tutaj: http://java.com/pl/download/manual.jsp

Po pierwszym uruchomieniu Eclipse CDT, gdy mamy już Javę zostaniemy zapytani o domyślny katalog projektów etc, warto wybrać jakiś sensowny, na rzadko czyszczonym dysku, i zaznaczyć że nie chcemy więcej widzieć tego pytania. Niestety, uruchomione teraz środowisko wymaga jeszcze kompilatora.

Do naszych celów, że tak powiem edukacyjnych polecam MinGW. Najlepiej z TEJ STRONY pobrać "Automated MinGW Installer". Po jego uruchomieniu i zdecydowaniu że chcemy pobrać i zainstalować najlepiej wybrać wersję bieżącą (Current) a w liście programów do "MinGW base tools" dodać "g++ compiler" oraz "MinGW make". Pozostałe języki chętnie was uraczą swoimi kompilatorami gdy będziecie ich potrzebować . Po wybraniu ścieżki MinGW pobierze się i zainstaluje na twoim komputerze. Po jego instalacji można skasować ściągnięte instalki czy archiwa, oraz uruchomić system Windows ponownie.

Na dobry początek wykorzystajmy nasze nowe środowisko do stworzenia prostego programu, ot HelloWorlda wyświechtanego.

Klikamy (już w uruchomionym programie) na File->New->C++ Project. Wpisujemy jego nazwę oraz wybieramy "ToolChain" MinGW GCC, a jako "Project type" wybieramy Hello World C++ Project. Po wypełnienie podstawowych danych, które Eclipse umieści w komentarzach, projekt zostanie utworzony. Możemy przeglądać jego zawartość w drzewku po lewej, źródła domyślnie są w podkatalogu projektu o nazwie src. Projekt taki automatycznie się zbuduje (kompilacja i linkowanie), i możemy uruchomić go w małej dołączonej konsoli klikając zieloną strzałkę. Dodajmy do naszego projektu klasę, ot na przykład prymitywny 2 wymiarowy wektor. Niknięcie na File->New->Class włączy bardzo przyjemnego kreatora, który po podaniu nazwy i kilku własności wygeneruje potrzebne pliki wraz z domyślnymi zawartościami (konstrukcje warunkowego dołączania, konstruktor i destruktor etc).

Kod wygenerowany:

Listing:

//============================================================================
// Name : witaj.cpp
// Author : twoje imie
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include
using namespace std;
int main() {
cout << "Hello World!!!" << endl; // prints Hello World!!!
return 0;
}

Listing:

/*
* Vector.h
*
* Created on: 2008-10-15
* Author: twoje imie
*/
#ifndef VECTOR_H_
#define VECTOR_H_
class Vector {
public:
Vector();
~Vector();
};
#endif /* VECTOR_H_ */

Listing:

/*
* Vector.cpp
*
* Created on: 2008-10-15
* Author: twoje imie
*/
#include "Vector.h"
Vector::Vector() {
// TODO Auto-generated constructor stub
}
Vector::~Vector() {
// TODO Auto-generated destructor stub
}

Podsumowują: począwszy od pierwszego programu, Eclipse zmniejsza nakład pracy potrzebny aby napisać jakikolwiek program. Od kolorowania składni, poprzez wskazywanie linijek w których wystąpiły błędy i ostrzeżenia, jak i bogate możliwości konfiguracji, możliwość "podpowiadania" części kodu (możesz ją ręcznie wywoła za pomocą Ctrl+Spacja) a kończąc na obsłudze setek przydatnych wtyczek i wolności tego środowiska: przyda się ono każdemu piszącemu programy w C lub C++. Zachęcam do samodzielnego eksplorowania ustawień (Windows->Preferences) jak i sprawdzaniu rożnych funkcji dostępnych poprzez Menu programu czy menu kontekstowe.

Przeładowanie operatorów cześć 1.

Krzysiek Wesołowski — Mon, 14 Jul 2008 10:41:04 +0000

Słowem wstępu

Postaram się opisać na podstawie już wcześniej stworzonego programu (operacja na wektorach) jak przeładowywać w C++ podstawowe operatory.

Postaram się skupić na samym przeładowaniu, bez wchodzenia w szczegóły samego działania.

Operatory powinno się przeładowywać właśnie tam, gdzie ich działanie jest jednoznaczne na pierwszy rzut oka: działania arytmetyczne, operatory wejścia, wyjścia i inne, rzadziej używane o których wspomnę innym razem.

Ogólną ideą która powinna przyświecać przeładowywaniu to tworzenie przewidywalnych, zachowujących się analogicznie jak te wbudowane operatorów.

Przeładowany operator to po prostu funkcja o nazwie operator z dopisaną końcówką charakteryzującą operator, np operator+, operator*= etc. Samą funkcje można zdefiniować na dwa sposoby:

Jako funkcje składową klasy
wtedy napisanie obiekt1+obiekt2 oznacza wywołanie: obiekt1.operator+(obiekt2)
Jako funkcje globalną
wtedy napisanie obiekt1+obiekt2 oznacza wywołanie: operator+(obiekt1,obiekt2)

Operatory dodawania

Występuje w kilku wariacjach:

Zwykły operator dodawania:

Założenia:

Dodaje elementy tego samego/podobnego typu do siebie
Nie zmienia żadnego z elementów (żeby działało na obiektach stałych tak jak 2+5)
Wynik powinien być zwrócony przez wartość (gdyż obiekty wewnątrz funkcji utworzone mogą zostać zniszczone już po jej zakończeniu)

Przykład:

Listing:

class Vector {
...
public:
Vector operator+(const Vector& rhs) const;
...
}

Listing:

Vector operator+(const Vector& lhs,const Vector& rhs);

Obie metody działają, natomiast zdecydowanie elegantsza wydaje się dla mnie być ta pierwsza, gdyż w gruncie rzeczy operator ten jest tak silnie związany z klasa że powinien być jej funkcją składową.

Operator dodawania do lewej strony:

Założenia:

Dodaje elementy tego samego/podobnego typu do siebie
Zmienia element po lewej stronie (zwiększając go o wartość tego po prawej)
Wynik powinien być zwrócony przez referencje, tak aby wskazywał na właśnie przypisany obiekt. Zwracanie wyniku przez wartość byłoby nieefektywne z względu na pamięć (zbędne kopiowanie), natomiast ważne jest zwracanie w ogóle, aby poprawna była konstrukcja while( (i+=6)<20 )

Przykład, jako funkcja składowa (do takich będę się teraz ograniczał, ew zmiany są analogiczne jak powyżej)

Listing:

class Vector {
...
public:
Vector& operator+=(const Vector& rhs);
...
}

Operator odejmowania czyli operator- i operator -= są analogiczne, przejde więc do operatorów mnożenia. Wektory można mnożyć na 3 sposoby: wektor*liczba, liczba*wektor, wektor*liczba, oraz wektor*wektor (skalarne).

Mnożenie wektor*liczba

Założenia:

Mnoży wektor po lewej stronie razy liczbę
Zwraca nowy,przemnożony wektor
Zwraca oczywiście przez wartość

Przykład:

Listing:

class Vector {
...
public:
Vector operator*(const int& rhs) const;
...
}

Mnożenie wektor*=liczba

Założenia:

Mnoży wektor po lewej stronie razy liczbę
Zmienia lewą stronę wpisując wynik
Zwraca referencje do przemnożonego wektora (z tych samych przyczyn co operator+=)

Przykład:

Listing:

class Vector {
...
public:
Vector& operator*=(const int& rhs);
...
}

Nie miałoby natomiast sensu napisanie: liczba*=wektor, gdyż takie działanie, teoretycnzie powinno liczbe zmienic na wektor, co jest niemożliwe. Pozostaje nam operator liczba*wektor. Ponieważ operator jako skladowa swoja klase musi mieć po lewej stronie, jedynym wyjściem jest utworzenie funkcji globalnej, spełniającej praktycznie te same założenia co wektor*liczba.

Listing:

Vector operator* (const int& lhs,const Vector& rhs);

Często aby moc korzystać z zmiennych prywatnych klasy Vector, takie funkcje nie deklaruje się poza ich ciałem, tylko wewnątrz definicji klasy jako funkcje zaprzyjaźnione:

Listing:

class Vector {
...
friend Vector operator* (const int& lhs,const Vector& rhs);
...
public:
...
}

Ostatni operator wart wymienia to proste mnożenie skalarne wektorów, którego przykład poniżej:

Listing:

class Vector {
...
public:
int operator*(const Vector& rhs) const;
...
}

Często dużo więcej można odczytać i zrozumieć z przykładowego kodu, dlatego poniżej zamieszczam w miarę dopieszczona klasę Vector

Udokumentowane źródła klasy Vector

Krzysztof Wesołowski » c++

Eclipse CDT – środowisko C/C++

Przeładowanie operatorów cześć 1.

Słowem wstępu

Operatory dodawania

Zwykły operator dodawania:

Operator dodawania do lewej strony:

Mnożenie wektor*liczba

Mnożenie wektor*=liczba