Programlamaya ve C++'a Giriş
Bu online eğitim daha ileri düzey kavramlarla devam etmektedir. Lütfen 3. Bölüm'ü okuyun. Bu modülde, işaretçileri kullanmaya ve nesnelerle çalışmaya başlamaya odaklanacağız.
2. Örnekle Öğrenin
Bu modülde, parçalara ayırma, işaretçileri anlama ve nesneler ile sınıfları kullanma konusunda daha fazla alıştırma yapmayı hedefliyoruz. Aşağıdaki örnekleri inceleyin. İstendiğinde programları kendiniz yazın veya denemeleri yapın. İyi bir programcı olmanın anahtarının pratik yapmak, pratik yapmak, pratik yapmak olduğunu ne kadar vurgulasak azdır!
1. Örnek: Daha Fazla Ayrıştırma Uygulaması
Basit bir oyundan şu çıkışı düşünün:
Welcome to Artillery. You are in the middle of a war and being charged by thousands of enemies. You have one cannon, which you can shoot at any angle. You only have 10 cannonballs for this target.. Let's begin... The enemy is 507 feet away!!! What angle? 25< You over shot by 445 What angle? 15 You over shot by 114 What angle? 10 You under shot by 82 What angle? 12 You under shot by 2 What angle? 12.01 You hit him!!! It took you 4 shots. You have killed 1 enemy. I see another one, are you ready? (Y/N) n You killed 1 of the enemy.
İlk gözlem, program başına bir kez görüntülenen giriş metnidir birkaç adım var. Her tur için düşman mesafesini tanımlamak üzere bir rastgele sayı üreteci Oynatıcıdan açı girişini almak için bir mekanizmaya ihtiyacımız var ve bu açıkça bir döngü yapısındadır çünkü düşmanı vurana kadar tekrar eder. Ayrıca mesafeyi ve açıyı hesaplayan bir fonksiyona ihtiyacı var. Son olarak, düşmanı vurmak için kaç atış yaptığımızı ve programın yürütülmesi sırasında kaç düşmanı vurduğumuzu takip etmemiz gerekir. Ana programın ana hatlarını aşağıda görebilirsiniz.
StartUp(); // This displays the introductory script.
killed = 0;
do {
killed = Fire(); // Fire() contains the main loop of each round.
cout << "I see another one, care to shoot again? (Y/N) " << endl;
cin >> done;
} while (done != 'n');
cout << "You killed " << killed << " of the enemy." << endl;
Yangın prosedürü, oyunun oynanışını ele alır. Bu işlevde, düşman mesafesini almak için rastgele sayı üreteci çağırırız ve ardından oyuncunun girişini almak ve düşmana isabet edip etmediğini hesaplamak için döngüyü ayarlarız. Döngüdeki koruma koşulu, düşmana vurmaya ne kadar yaklaştığımızı gösterir.
In case you are a little rusty on physics, here are the calculations: Velocity = 200.0; // initial velocity of 200 ft/sec Gravity = 32.2; // gravity for distance calculation // in_angle is the angle the player has entered, converted to radians. time_in_air = (2.0 * Velocity * sin(in_angle)) / Gravity; distance = round((Velocity * cos(in_angle)) * time_in_air);
cos() ve sin() çağrıları nedeniyle math.h dosyasını eklemeniz gerekir. Bu programı yazmaya çalışın. Bu program, problem çözümü ve temel C++'ya göz atma konusunda mükemmel bir alıştırmadır. Her işlevde yalnızca bir görev yapmayı unutmayın. Bu, şimdiye kadar yazdığımız en karmaşık programdır. Bu nedenle, tamamlamanız biraz zaman alabilir. Çözümümüzü burada bulabilirsiniz.
2. Örnek: İşaretçilerle alıştırma yapma
İşaretçilerle çalışırken unutulmaması gereken dört nokta vardır:- İşaretçiler, bellek adreslerini tutan değişkenlerdir. Bir program yürütülürken tüm değişkenler, her biri kendi benzersiz adresinde veya konumunda bellekte saklanır.
İşaretçi, işaret yerine bir bellek adresi içeren özel bir değişken türüdür.
daha yüksek bir bütçe
belirleyebilir. Normal bir değişken kullanıldığında verilerin değiştirilmesi gibi
işaretçide depolanan adresin değeri işaretçi değişken olarak değiştirilir
manipüle edilir. Bir örnek verelim:
int *intptr; // Declare a pointer that holds the address // of a memory location that can store an integer. // Note the use of * to indicate this is a pointer variable. intptr = new int; // Allocate memory for the integer. *intptr = 5; // Store 5 in the memory address stored in intptr.. - Genelde işaretçinin bir "noktaya" konuma taşımasına yardımcı olur.
("Pointee") Dolayısıyla yukarıdaki örnekte intptr, işaret edilen 5 değerini gösterir.
"Yeni" seçeneğinde operatörünün tam sayımız için bellek ayırması Pointee'ye dokunun. İşaretçiye erişmeye çalışmadan önce bunu yapmamız gerekir.
int *ptr; // Declare integer pointer. ptr = new int; // Allocate some memory for the integer. *ptr = 5; // Dereference to initialize the pointee. *ptr = *ptr + 1; // We are dereferencing ptr in order // to add one to the value stored // at the ptr address.* operatörü, C'de referans göstermeyi kaldırmak için kullanılır. En yaygın hatalardan biri C/C++ programcılarının işaretçilerle çalışırken ilk kullanıma hazırlamayı unutmaları karar veren kişidir. Bu durum bazen bilinmeyen veriler içeren bir konum. Bu dosyayı değiştirmeye çalışırsak küçük bellek bozulmasına neden olarak tespit edilmesini zorlaştırabilir.
- İki işaretçi arasındaki işaretçi ataması, bu işaretçilerin aynı noktayı işaret etmesini sağlar.
Dolayısıyla y = x; atama, y'nin x ile aynı işaretçiyi göstermesini sağlar. İşaretçi ataması
kullanıcı işaretçiye dokunmaz. Yalnızca bir işaretçiyi aynı konuma sahip olacak şekilde değiştirir
kullanabilirsiniz. İşaretçi atamasından sonra iki işaretçi, işaret edileni "paylaşır".
void main() {
int* x; // Allocate the pointers x and y
int* y; // (but not the pointees).
x = new int; // Allocate an int pointee and set x to point to it.
*x = 42; // Dereference x and store 42 in its pointee
*y = 13; // CRASH -- y does not have a pointee yet
y = x; // Pointer assignment sets y to point to x's pointee
*y = 13; // Dereference y to store 13 in its (shared) pointee
}
Bu kodun izlemesi aşağıda verilmiştir:
| 1. İki işaretçi (x ve y) ayırın. İşaretçileri ayırmak herhangi bir işaretçi ayırmaz. |  |
| 2. Bir işaretçi atayın ve x değerini bu işaretçiyi işaret edecek şekilde ayarlayın. |  |
| 3. x referansını işaretçisindeki 42 mağazasına girin. Bu, iş kırılım yapısının işlemini tekrarlar. x'ten başlayın, erişmek için oku takip edin çok önemliydi. |  |
| 4. y referansını işaretçisinde 13'ü depolamaya çalışın. Bu kilitlenmenin nedeni: hiç atanmamış. |  |
| 5. Y = x; Böylece y, x'in işaretçisini işaret eder. Şimdi x ve y seçeneği yani "paylaşıyor"dur. |  |
| 6. y referansını işaretçisinde 13'ü depolamak için kullanmaya çalışın. Bu sefer işe yarıyor çünkü önceki ödev size bir işaretçi verdi. |  |
Gördüğünüz gibi resimler, işaretçi kullanımını anlamada çok yardımcı olur. İşte başka bir örnek verelim.
int my_int = 46; // Declare a normal integer variable.
// Set it to equal 46.
// Declare a pointer and make it point to the variable my_int
// by using the address-of operator.
int *my_pointer = &my_int;
cout << my_int << endl; // Displays 46.
*my_pointer = 107; // Derefence and modify the variable.
cout << my_int << endl; // Displays 107.
cout << *my_pointer << endl; // Also 107.
Bu örnekte, "new" [yeni] değişkeniyle hiçbir zaman operatörümüzü kullanabilirsiniz. Normal bir tam sayı değişkeni tanımladık ve bunu işaretçiler aracılığıyla değiştirdik.
Bu örnekte, ayırma özelliğini devre dışı bırakan delete operatörünün kullanımını gösteriyoruz. ve daha karmaşık yapılar için nasıl ayırma yapabileceğimizi konuşacağız. Ele alacağımız konular: bellek organizasyonunu (yığın ve çalışma zamanı yığını) ayrıntılı bir şekilde inceleyeceğiz. Şimdilik, yığınlar, çalışan programların kullanabileceği boş bir bellek deposu olarak düşünülebilir.
int *ptr1; // Declare a pointer to int. ptr1 = new int; // Reserve storage and point to it. float *ptr2 = new float; // Do it all in one statement. delete ptr1; // Free the storage. delete ptr2;
Bu son örnekte, değerleri referans yoluyla iletmek için işaretçilerin nasıl kullanıldığını gösteriyoruz. işlevine dönüştürdüğümüz anlamına gelir. Bir fonksiyondaki değişkenlerin değerlerini bu şekilde değiştiririz.
// Passing parameters by reference.
#include <iostream>
using namespace std;
void Duplicate(int& a, int& b, int& c) {
a *= 2;
b *= 2;
c *= 2;
}
int main() {
int x = 1, y = 3, z = 7;
Duplicate(x, y, z);
// The following outputs: x=2, y=6, z=14.
cout << "x="<< x << ", y="<< y << ", z="<< z;
return 0;
}
Yinelenen işlev tanımındaki &'leri bağımsız değişkenlerin dışında bırakırsak değişkenleri "değere göre" iletiriz. Başka bir deyişle, belirtir. İşlevdeki değişkende yapılan değişiklikler kopyayı değiştirir. Orijinal değişkeni değiştirmezler.
Bir değişken referans yoluyla iletildiğinde değerinin kopyasını iletmeyiz, değişkenin adresini fonksiyona geçiriyoruz. Projenin gidişatı boyunca yerel değişkene yaptığımız işlem, geçirilen orijinal değişkeni gerçekten değiştirmektedir.
C programcısıysanız bu yepyeni bir yeniliktir. Aynı şeyi C'de de yapabiliriz. Duplicate() tanımlanıyor Yinelenen(int *x) olarak değişirse Bu durumda x bir int işaretçisidir. Ardından &x (x adresi) bağımsız değişkeniyle Duplicate() çağrısını ve x dahilinde Yinelenen() (aşağıya bakın). Ancak C++, değerleri fonksiyonlara aktarmak için daha basit bir yol eski "C"yi yöntemi hâlâ işe yarıyor.
void Duplicate(int *a, int *b, int *c) {
*a *= 2;
*b *= 2;
*c *= 2;
}
int main() {
int x = 1, y = 3, z = 7;
Duplicate(&x, &y, &z);
// The following outputs: x=2, y=6, z=14.
cout << "x=" << x << ", y=" << y << ", z=" << z;
return 0;
}
C++ referanslarında, bir değişkenin adresini iletmemiz gerekmez veya çağrılan işlevin içindeki değişkenin referansını kaldırmamız gerekir mi?
Aşağıdaki program çıktısı ne olur? Öğrenmek için bir anı resmi çizin.
void DoIt(int &foo, int goo);
int main() {
int *foo, *goo;
foo = new int;
*foo = 1;
goo = new int;
*goo = 3;
*foo = *goo + 3;
foo = goo;
*goo = 5;
*foo = *goo + *foo;
DoIt(*foo, *goo);
cout << (*foo) << endl;
}
void DoIt(int &foo, int goo) {
foo = goo + 3;
goo = foo + 4;
foo = goo + 3;
goo = foo;
}
Doğru yanıtı bulup bulmadığınızı görmek için programı çalıştırın.
3. Örnek: Değerleri Referansa Göre Aktarma
Bir aracın hızını ve bir miktarı giriş olarak alan accelerate() adlı bir işlev yazın. Fonksiyon, aracı hızlandırmak için hızı hıza ekler. Hız parametresi, referans ve miktar ile değer üzerinden iletilmelidir. Çözümümüze buradan ulaşabilirsiniz.
4. Örnek: Sınıflar ve Nesneler
Şu sınıfı göz önünde bulundurun:
// time.cpp, Maggie Johnson
// Description: A simple time class.
#include <iostream>
using namespace std;
class Time {
private:
int hours_;
int minutes_;
int seconds_;
public:
void set(int h, int m, int s) {hours_ = h; minutes_ = m; seconds_ = s; return;}
void increment();
void display();
};
void Time::increment() {
seconds_++;
minutes_ += seconds_/60;
hours_ += minutes_/60;
seconds_ %= 60;
minutes_ %= 60;
hours_ %= 24;
return;
}
void Time::display() {
cout << (hours_ % 12 ? hours_ % 12:12) << ':'
<< (minutes_ < 10 ? "0" :"") << minutes_ << ':'
<< (seconds_ < 10 ? "0" :"") << seconds_
<< (hours_ < 12 ? " AM" : " PM") << endl;
}
int main() {
Time timer;
timer.set(23,59,58);
for (int i = 0; i < 5; i++) {
timer.increment();
timer.display();
cout << endl;
}
}
Sınıf üyesi değişkenlerinin sonlarında alt çizgi olduğuna dikkat edin. Bu, yerel değişkenler ve sınıf değişkenlerini birbirinden ayırt etmek için yapılır.
Bu sınıfa bir azalma yöntemi ekleyin. Çözümümüze buradan ulaşabilirsiniz.
Bilimin harikaları: Bilgisayar Bilimi
Egzersizler
Bu kursun ilk modülünde olduğu gibi alıştırmalar ve projeler için çözümler sunmuyoruz.
Programın İyi Olduğunu Unutmayın...
..., herhangi bir fonksiyonun çalıştırıldığı fonksiyonlara, mantıksal olarak tek bir görev yapıyor.
... programın ne yapacaklarını özetleyen bir ana programa sahip.
... açıklayıcı işlev, sabit ve değişken adlarına sahiptir.
... her türlü "sihirden" kaçınmak için sabit değerler kullanır daha fazla bilgi edindiniz.
... kullanıcı dostu bir kullanıcı arayüzüne sahip.
Isınma Egzersizleri
- 1. alıştırma
36 tam sayısının kendine özgü bir özelliği vardır: Tam bir karedir ve 1'den 8'e kadar olan tam sayıların toplamı. Bunun gibi bir sonraki sayı 1225. 352 ve 1'den 49'a kadar olan tam sayıların toplamıdır. Sonraki numarayı bul bu, tam kare ve aynı zamanda bir serinin 1...n. sayısının toplamıdır. Bu sonraki numara 32767'den büyük olabilir. Bildiğiniz kitaplık işlevlerini, (ya da matematik formüllerini) kullanabilirsiniz. Bir sayının tam kare mi yoksa bir serinin toplamı mı olduğunu belirlemek için bu programı for döngüleri kullanarak da yazabilirsiniz. (Not: Makinenize ve programınıza bağlı olarak bu sayıyı bulmak biraz zaman alabilir.)
- Alıştırma 2
Üniversite kitabeviniz gelecek için işletmesini tahmin ederken yardımınıza ihtiyaç duyuyor olduğunu görebilirsiniz. Deneyimler, satışların kitabın gerekli olup olmadığına büyük ölçüde bağlı olduğunu göstermiştir bir kurs için mi yoksa isteğe bağlı olarak mı ayarlandığı ve sınıfta kullanılıp kullanılmadığı kontrol edin. Zorunlu olan yeni bir ders kitabı, yeni kayıtların% 90'ına satılacak. ancak daha önce sınıfta kullanılıyorsa yalnızca% 65'i satın alma işlemi gerçekleştiriyor. Aynı şekilde, Potansiyel kaydın% 40'ı isteğe bağlı yeni bir ders kitabı satın alacak. Ancak %20'si satın alma işlemi gerçekleştirmeden önce sınıfta kullanılan (Burada "ikinci el" ibaresinin bulunduğunu unutmayın ikinci el kitaplar anlamına gelmez.)
Bir dizi kitap girişi kabul eden bir program yazın (kullanıcı giriş yapana kadar bir koruyucu). Her kitap için şunları isteyin: kitabın kodunu, tek kopyanın maliyetini sayısı, potansiyel sınıf kaydı, ve kitabın gerekli/isteğe bağlı, yeni/geçmişte kullanılıp kullanılmadığını gösteren veriler. Farklı tüm giriş bilgilerini, aşağıdaki metinlerle birlikte güzel biçimlendirilmiş bir ekranda kaç kitap sipariş edilmesi gerektiği (varsa, yalnızca yeni kitapların sipariş edildiğini unutmayın), toplam maliyeti gösterilir.
Tüm girişler tamamlandıktan sonra, tüm kitap siparişlerinin toplam maliyeti gösterilir ve Mağaza liste fiyatının% 80'ini öderse beklenen kâr. Henüz bir programa giren büyük veri kümeleriyle başa çıkmanın yollarını tartıştık (ayrıca ayarlandı!), bir kerede tek bir kitabı işleyin ve o kitabın çıkış ekranını görüntüleyin. Ardından, kullanıcı tüm verileri girmeyi tamamladığında programınız şu çıktıyı çıkarmalıdır: toplam ve kâr değerleri.
Kod yazmaya başlamadan önce bu programın tasarımı üzerine düşünmek için biraz zaman ayırın. Fonksiyon grubuna ayırın ve şuna benzer bir main() işlevi oluşturun: soruna yönelik çözümünüz için bir özet. Her işlevin bir görev gerçekleştirdiğinden emin olun.
Aşağıda örnek bir çıkış verilmiştir:
Please enter the book code: 1221 single copy price: 69.95 number on hand: 30 prospective enrollment: 150 1 for reqd/0 for optional: 1 1 for new/0 for used: 0 *************************************************** Book: 1221 Price: $69.95 Inventory: 30 Enrollment: 150 This book is required and used. *************************************************** Need to order: 67 Total Cost: $4686.65 *************************************************** Enter 1 to do another book, 0 to stop. 0 *************************************************** Total for all orders: $4686.65 Profit: $937.33 ***************************************************
Veritabanı Projesi
Bu projede, temel Scrum araçlarını kullanarak kullanır.
Programımız, bestecilerin ve ilgili bilgilerin yer aldığı bir veritabanını yönetmemize olanak sağlayacak merak ediyor olabilirsiniz. Programın özellikleri arasında şunlar yer alır:
- Yeni bir besteci ekleme olanağı
- Bir besteciyi sıralama yeteneği (ör. ne kadar sevdiğimizi veya sevmediğimizi belirtme bestecinin müziği)
- Veritabanında bulunan tüm bestecileri görüntüleme
- Tüm bestecileri sıralamaya göre görüntüleme
"Yazılım tasarımı oluşturmanın iki yolu vardır: Bir yol, açıkça eksiklik bulunmaması için tasarımı çok basit hale getirmektir. Diğer yol ise açıkça eksiklik bulunmaması için tasarımı çok karmaşık hale getirmektir. İlk yöntem çok daha zor." - C.A.R. Hoare
Pek çoğumuz "prosedürel", "çaba gerektiren" bir yöntem bahsedeceğiz. İlk olarak "Program ne yapmalı?" sorusuyla başlayalım. Bir sorunun çözümünü, her biri sorunun bir bölümünü çözen görevlere ayırırız. Bu görevler, programımızdaki sıralı olarak adlandırılan fonksiyonlarla eşlenir. işlevinden emin olun. Bu adım adım açıklamalı yaklaşım, çözmemiz gereken bazı sorunlar için idealdir. Ama çoğu zaman programlarımız doğrusal programlardan ibaret değildir. etkinlik veya görev dizisidir.
Nesne odaklı (OO) yaklaşımıyla, "Gerçek dünya kullanıyor olmam gerekiyor. Programı açıklandığı şekilde görevlere ayırmak yerine bunu fiziksel nesnelerin modellerine böleriz. Bu fiziksel cisimler bir dizi nitelikle tanımlanan bir durum ve bu kişilerin ne tür davranışlar veya eylemler tam olarak anlayabilmelidir. İşlemler nesnenin durumunu değiştirebilir veya başka nesnelerin eylemlerini çağırmaktır. Temel prensibi, nesnenin "bilmesi" nasıl bir yaklaşıma sahiptir.
OO tasarımında, fiziksel nesneleri sınıf ve nesneler açısından tanımlarız. özellikler ve davranışlar. Bir OO programında genellikle çok sayıda nesne bulunur. Ancak bu nesnelerin çoğu temelde aynıdır. Aşağıdakileri göz önünde bulundurun.
Bu diyagramda, Apple sınıfında olan iki nesne tanımladık. Her nesne sınıfla aynı özelliklere ve işlemlere sahiptir, ancak nesne belirli bir elma türünün özelliklerini tanımlar. Ayrıca, Görüntülü Reklam Ağı işlemi, söz konusu nesnenin özelliklerini görüntüler, ör. "Yeşil" ve "Ekşi" olarak da adlandırılır.
OO tasarımı bir dizi sınıftan, yani bu sınıflarla ilişkili verilerden oluşur. ve sınıfların gerçekleştirebileceği işlem kümesidir. Ayrıca, reklam sıralamasının nasıl etkileşime girdiğini gösterir. Bu etkileşim nesneler tarafından gerçekleştirilebilir başka sınıflara ait nesnelerin eylemlerini çağıran bir sınıfın Örneğin, bir dizinin renk ve tadını üreten bir AppleExiter sınıfına sahip olabilir Display() yöntemini çağırarak Apple nesnelerinin sayısını azaltır.
OO tasarımı yaparken uyguladığımız adımlar şunlardır:
- Sınıfları tanımlayın ve genel olarak her sınıftaki bir nesnenin veri olarak neyi depoladığını ve ne yapabileceğini tanımlayın.
- Her sınıfın veri öğelerini tanımlayın
- Her sınıfın işlemlerini ve tek bir sınıfa ait bazı işlemlerin nasıl olabileceğini tanımlayın
ilgili diğer sınıfların eylemleri kullanılarak uygulanır.
Büyük bir sistemde bu adımlar farklı ayrıntı düzeylerinde tekrarlı olarak gerçekleşir.
Besteci veritabanı sistemi için her şeyi kapsayan bir Composer sınıfına ihtiyacımız var. tek bir bestecide depolamak istediğimiz veriler de var. Bu sınıfın bir nesnesi kendisini tanıtma veya sıralamasını değiştirme (sıralama değiştirme) ve özelliklerini gösterme.
Ayrıca, Composer nesnelerinden oluşan bir koleksiyona da ihtiyacımız vardır. Bunun için bir Veritabanı sınıfı tanımlıyoruz. tek tek yöneten hesaptır. Bu sınıftaki bir nesne ekleme veya alma işlemi yapabilir Nesneleri oluşturun ve görüntüleme işlemini çağırarak nesneleri tek tek görüntüleyin Composer nesnesidir.
Son olarak, etkileşimli işlemler sağlamak için bir tür kullanıcı arayüzüne ihtiyacımız var. var. Bu bir yer tutucu sınıftır. Yani kullanıcı arayüzünün nasıl görüneceğini henüz bilmiyoruz ancak bir arayüze ihtiyacımız olduğunu biliyoruz. Belki grafiksel veya metin tabanlı olabilir. Şimdilik, her bir reklamın bu bilgileri daha sonra girebiliriz.
Artık besteci veritabanı uygulaması sınıflarını belirlediğimize göre, sıradaki adım, sınıflar için özellikleri ve işlemleri tanımlamaktır. Daha oturup kalem kağıt veya kâğıt UML veya CRC kartları veya OOD sınıf hiyerarşisini ve nesnelerin nasıl etkileşime girdiğini ayrıntılarıyla görebilirsiniz.
Besteci veritabanımızda, besteci veritabanımızda alakalı istediğimiz verileri topluyoruz. Ayrıca, projeniz için manipüle etme yöntemleri sıralamaları ve verilerin görüntülenmesidir.
Veritabanı sınıfının Composer nesnelerini barındırmak için bir tür yapıya ihtiyacı vardır. Yapıya yeni bir Composer nesnesi eklememiz ve bunu mümkün olduğunca belirli bir Composer nesnesini alma. Aynı zamanda tüm nesneleri sıralamaya göre yapılır.
Kullanıcı Arayüzü sınıfı, işlevleri ve kullanıcı deneyimini Veritabanı sınıfındaki çağrı işlemleri.
Sınıflar kolayca anlaşılıyorsa ve özellikleri ile işlemleri netse, komponisör uygulamasında olduğu gibi sınıfları tasarlamak nispeten kolaydır. Ama sınıfların ilişkisi ve etkileşimi konusunda aklınızda sorularınız varsa en iyisidir. Başlamadan önce buradaki ayrıntıların üzerinden geçmek adım adım açıklayacağım.
Tasarımı net bir şekilde anlayıp değerlendirdikten sonra (bu konuda daha fazla bilgi yakında), her sınıf için arayüzü tanımlarız. Uygulama konusunda endişelenmiyoruz unsurların ve eylemlerin hangileri olduğunu ve bunların hangi bir sınıfın diğer sınıflar tarafından kullanılabilir.
C++'ta normalde bunu her sınıf için bir başlık dosyası tanımlayarak yaparız. Besteci sınıfında, bir bestecide depolamak istediğimiz tüm veriler için gizli veri üyeleri yer alıyor. Erişimciler ("get" yöntemleri) ve mutatörler ("set" yöntemleri) ile birincil işlemleri ekleyebilirsiniz.
// composer.h, Maggie Johnson
// Description: The class for a Composer record.
// The default ranking is 10 which is the lowest possible.
// Notice we use const in C++ instead of #define.
const int kDefaultRanking = 10;
class Composer {
public:
// Constructor
Composer();
// Here is the destructor which has the same name as the class
// and is preceded by ~. It is called when an object is destroyed
// either by deletion, or when the object is on the stack and
// the method ends.
~Composer();
// Accessors and Mutators
void set_first_name(string in_first_name);
string first_name();
void set_last_name(string in_last_name);
string last_name();
void set_composer_yob(int in_composer_yob);
int composer_yob();
void set_composer_genre(string in_composer_genre);
string composer_genre();
void set_ranking(int in_ranking);
int ranking();
void set_fact(string in_fact);
string fact();
// Methods
// This method increases a composer's rank by increment.
void Promote(int increment);
// This method decreases a composer's rank by decrement.
void Demote(int decrement);
// This method displays all the attributes of a composer.
void Display();
private:
string first_name_;
string last_name_;
int composer_yob_; // year of birth
string composer_genre_; // baroque, classical, romantic, etc.
string fact_;
int ranking_;
};
Database sınıfı da oldukça basittir.
// database.h, Maggie Johnson
// Description: Class for a database of Composer records.
#include <iostream>
#include "Composer.h"
// Our database holds 100 composers, and no more.
const int kMaxComposers = 100;
class Database {
public:
Database();
~Database();
// Add a new composer using operations in the Composer class.
// For convenience, we return a reference (pointer) to the new record.
Composer& AddComposer(string in_first_name, string in_last_name,
string in_genre, int in_yob, string in_fact);
// Search for a composer based on last name. Return a reference to the
// found record.
Composer& GetComposer(string in_last_name);
// Display all composers in the database.
void DisplayAll();
// Sort database records by rank and then display all.
void DisplayByRank();
private:
// Store the individual records in an array.
Composer composers_[kMaxComposers];
// Track the next slot in the array to place a new record.
int next_slot_;
};
Besteciye özgü verileri ayrı bir URL'de dikkatli bir şekilde sınıfını kullanır. Veritabanı sınıfına ve bu kayda doğrudan oradan erişti. Ama bu, alt nesnelleştirmedir. Örneğin, nesnelerle çok fazla elimizden geleni yaptık.
Besteci ve Veritabanı'nın uygulanması üzerinde çalışmaya başladığınızda göreceğiniz gibi, daha basit olduğunu gördük. Özellikle, bir Composer nesnesi üzerinde ayrı atomik işlemlere sahip olmak, işlemi büyük ölçüde basitleştirir Display() yöntemlerinin yerini alır.
Tabii ki "fazla nesnelleştirme" diye bir şey de var. burada: her şeyi sınıf haline getirmeye çalışıyoruz veya ihtiyacımız olandan daha fazla sınıfımız var. Bir bulmanıza yardımcı olabilir. Her programcının bu alıştırmada farklı görüşlere sahip olacaktır.
Aşırı veya az nesnelleştirip uygulamadığınızı belirlemek çoğu zaman zaman çizelgesi oluşturmayı öğrendiniz. Daha önce de belirttiğim gibi, ders çıkarmak için bu sayede yaklaşımınızı analiz edebilirsiniz. Bu amaçla kullanılan yaygın bir notasyon UML (Unified Modeling Language)'dir. Composer ve veritabanı nesneleri için sınıfları tanımladığımıza göre, kullanıcının veritabanıyla etkileşim kurmasına olanak tanıyan bir arayüze ihtiyacımız var. Basit bir menüde yapın:
Composer Database --------------------------------------------- 1) Add a new composer 2) Retrieve a composer's data 3) Promote/demote a composer's rank 4) List all composers 5) List all composers by rank 0) Quit
Kullanıcı arayüzünü bir sınıf veya prosedürsel bir program olarak uygulayabiliriz. Değil C++ programında her şeyin bir sınıf olması gerekir. Aslında işleme sıralıysa bu menü programında olduğu gibi, bunu prosedürlere da dahil etmenin bir sakıncası yoktur. Bunu, "yer tutucu" olarak kalacak şekilde uygulamak önemlidir. Örneğin, bir noktada grafiksel bir kullanıcı arayüzü oluşturmak istiyorsak kullanıcı arayüzünde herhangi bir değişiklik yapması gerekmez.
Başvuruyu tamamlamamız gereken son şey, sınıfları test etmeye yönelik bir programdır. Composer sınıfı için girdiyi alan, ön belleğe yönlendiren bir oluşturucu nesnesini görüntüler ve sınıfın düzgün çalıştığından emin olmak için bunu görüntüler. Ayrıca Composer sınıfının tüm yöntemlerini çağırmak istiyoruz.
// test_composer.cpp, Maggie Johnson
//
// This program tests the Composer class.
#include <iostream>
#include "Composer.h"
using namespace std;
int main()
{
cout << endl << "Testing the Composer class." << endl << endl;
Composer composer;
composer.set_first_name("Ludwig van");
composer.set_last_name("Beethoven");
composer.set_composer_yob(1770);
composer.set_composer_genre("Romantic");
composer.set_fact("Beethoven was completely deaf during the latter part of "
"his life - he never heard a performance of his 9th symphony.");
composer.Promote(2);
composer.Demote(1);
composer.Display();
}
Database sınıfı için benzer bir test programına ihtiyacımız var.
// test_database.cpp, Maggie Johnson
//
// Description: Test driver for a database of Composer records.
#include <iostream>
#include "Database.h"
using namespace std;
int main() {
Database myDB;
// Remember that AddComposer returns a reference to the new record.
Composer& comp1 = myDB.AddComposer("Ludwig van", "Beethoven", "Romantic", 1770,
"Beethoven was completely deaf during the latter part of his life - he never "
"heard a performance of his 9th symphony.");
comp1.Promote(7);
Composer& comp2 = myDB.AddComposer("Johann Sebastian", "Bach", "Baroque", 1685,
"Bach had 20 children, several of whom became famous musicians as well.");
comp2.Promote(5);
Composer& comp3 = myDB.AddComposer("Wolfgang Amadeus", "Mozart", "Classical", 1756,
"Mozart feared for his life during his last year - there is some evidence "
"that he was poisoned.");
comp3.Promote(2);
cout << endl << "all Composers: " << endl << endl;
myDB.DisplayAll();
}
Bu basit test programlarının iyi bir ilk adım olduğunu ancak programın düzgün çalıştığından emin olmak için çıktıyı manuel olarak incelememiz gerektiğini unutmayın. Farklı bir sistem büyüdükçe, çıktıların manuel olarak denetlenmesi çok işe yaramaz hale gelir. Sonraki derste, kendi kendini kontrol eden test programlarını olabilir.
Uygulamamızın tasarımı tamamlandı. Sonraki adımda sınıflar ve kullanıcı arayüzü için .cpp dosyalarını uygulamanız gerekir.Başlamak için devam edin ve .h ve test sürücüsü kodunu kopyalayıp dosyalara yapıştırın ve derleyin.Tekliflerinizi otomatikleştirmek ve optimize etmek için test etmeyeceklerini öğrendiniz. Daha sonra, aşağıdaki arayüzü uygulayın:
Composer Database --------------------------------------------- 1) Add a new composer 2) Retrieve a composer's data 3) Promote/demote a composer's rank 4) List all composers 5) List all composers by rank 0) Quit
Kullanıcı arayüzünü uygulamak için Veritabanı sınıfında tanımladığınız yöntemleri kullanın. Yöntemlerinizi hataya dayanıklı hale getirin. Örneğin, sıralama her zaman 1-10 aralığında olmalıdır. Veritabanı sınıfındaki veri yapısı.
Unutmayın, tüm kodunuzun tekrar eden kodlama kurallarımıza uyması gerekir buradan inceleyebilirsiniz:
- Yazdığımız her program bir başlık yorumuyla başlar. Bu yorumda yazar, iletişim bilgileri, kısa bir açıklama ve kullanım (ilgiliyse). Her işlev/yöntem, çalışma ve kullanıma ilişkin bir yorumla başlar.
- Kodda, açıklayıcı yorumlar yapmak için tam cümleler kullanıyoruz. (örneğin işleme süreci karmaşıksa, net değilse, belgelenmez, veya önemli olduğunu düşünebilirsiniz.
- Her zaman açıklayıcı adlar kullanın: Değişkenler; _, my_variable parametresinde olduğu gibi kullanılır. İşlev/yöntem adlarında kelimeleri kullanabilirsiniz. Sabitler "k" ile başlar ve kelimeleri işaretlemek için büyük harf kullanın (ör. kDaysInweek).
- Girinti, ikinin katlarıdır. İlk seviye iki boşluk; daha ileri ise girinti gerekli olduğundan, dört boşluk, altı boşluk vb. kullanıyoruz.
Gerçek Dünyaya Hoş Geldiniz
Bu modülde, yazılım mühendisliğinin çoğunda kullanılan çok önemli iki aracı tanıtacağız. kuruluşlar. Birincisi bir derleme aracı, ikincisi ise yapılandırma yönetimi sistemidir. Bu araçların her ikisi de endüstriyel yazılım mühendisliğinde olmazsa olmazdır. birçok mühendis genellikle tek bir büyük sistem üzerinde çalışır. Bu araçlar ekipteki herkesin değişiklikleri kontrol etme ve derleme için etkili bir yöntem sağlama ve birçok program ve başlık dosyasından bir sisteme bağlanıyor.
Makefiles
Program oluşturma süreci genellikle ve gerekli dosyaları doğru sırayla bağlar. Çoğu zaman C++ dosyaları, bağımlılıklar, örneğin, bir programda çağrılan bir işlev, başka bir programda çok önemli. Belki de birkaç farklı .cpp dosyası için bir başlık dosyası gereklidir. Bir derleme aracı, bu bağımlılıklardan doğru derleme sırasını belirler. Ayrıca, yalnızca son derlemeden bu yana değişen dosyaları derleyecektir. Bu şekilde yüzlerce ya da binlerce dosyadan oluşan sistemlerde çok zaman harcıyor.
Yaygın olarak "make" adlı açık kaynaklı bir derleme aracı kullanılmaktadır. Bu konu hakkında bilgi edinmek için bu makaleyi okuyun. Composer Database uygulaması için bağımlılık grafiği oluşturup oluşturamadığınızı kontrol edin. ve sonra bunu bir Makefile'a çevireceğim.Buradan anlatabilmişimdir.
Konfigürasyon Yönetim Sistemleri
Endüstriyel yazılım mühendisliğinde kullanılan ikinci araç Yapılandırma Yönetimi'dir. (CM) tuşlarına basın. Bu, değişimi yönetmek için kullanılır. Bob ile Susan'ın teknoloji yazarları diyelim teknik kılavuz güncellemeleri üzerinde çalışıyor. Bir toplantı esnasında aynı dokümanın her bir bölümüne güncellenmesi için bir bölüm atar.
Teknik kılavuz, hem Bob hem de Susan'ın erişebileceği bir bilgisayarda depolanır. Herhangi bir CM aracı veya süreci kullanılmazsa bazı sorunlar ortaya çıkabilir. Bir olasılığı en düşük olanı, dokümanın depolandığı bilgisayarın muhtemelen Bob ve Susan aynı anda kullanım kılavuzu üzerinde çalışamaz. Bu, onları önemli ölçüde yavaşlatır.
Depolama bilgisayarı dokümana izin verdiğinde daha tehlikeli bir durum ortaya çıkar Bora ve Susan tarafından aynı anda açılması gerekir. Süreç şu şekilde olabilir:
- Bora, dokümanı bilgisayarında açar ve kendi bölümünde çalışır.
- Suzan dokümanı bilgisayarında açar ve kendi bölümünde çalışır.
- Bora, gerekli değişiklikleri yapar ve dokümanı depolama bilgisayarına kaydeder.
- Susan gerekli değişiklikleri yapıp dokümanı depolama bilgisayarına kaydeder.
Bu görselde, kontrol olmadığında ortaya çıkabilecek sorun gösterilmektedir teknik kılavuzun tek kopyasına ekleyin. Susan değişikliklerini kaydettiğinde yazar.
Bu tam olarak bir CM sisteminin kontrol edebileceği türden bir durumdur. Topluluk Yöneticisi ile hem Bob hem de Susan "check-out" yap kendilerine ait teknik belgenin ve bunlar üzerinde çalışmak. Bob, değişikliklerini tekrar kontrol ettiğinde sistem, Susan'ın kendine ait bir kopyası var. Susan kopyasını kontrol ettiğinde sistem Bob ve Susan'ın yaptığı değişiklikleri analiz eder iki değişiklik grubunu birleştirir.
CM sistemleri, yukarıda açıklandığı gibi eşzamanlı değişiklikleri yönetmenin ötesinde çeşitli özelliklere sahiptir. Birçok sistem, bir belgenin ilk oluşturulduğu andan itibaren tüm sürümlerinin arşivlerini saklar. Teknik bir kılavuzda bu, çok faydalı olabilir. Kullanıcı kılavuzun eski bir sürümüne sahip olduğunda ve teknik yazara sorular sorduğunda. CM sistemi, teknik yazarın eski sürüme erişmesine ve kullanıcının gördüğü ekranı görmesine olanak tanır.
CM sistemleri özellikle yazılımda yapılan değişikliklerin kontrol edilmesinde yararlıdır. Bu tür sistemlere Yazılım Yapılandırması Yönetimi (SCM) sistemleri denir. Bir büyük bir yazılım mühendisliği alanında çok sayıda bağımsız kaynak kodu dosyası veya bu sistemlerde değişiklik yapması gereken çok sayıda mühendisle SCM sisteminin kritik olduğu açıktır.
Yazılım Yapılandırma Yönetimi
SCM sistemleri basit bir fikri temel alır: Dosyalarınızın kesin kopyaları depoda tutulur. Kullanıcılar depodaki dosyaların kopyalarını kontrol eder, bu kopyalar üzerinde çalışabilir ve bunları tamamladıktan sonra da kontrol edebilirsiniz. SCM sistemleri tek bir ana hat üzerinde birden fazla kişi tarafından yapılan düzeltmeleri yönetir ve izler ayarlandı.
Tüm SCM sistemleri aşağıdaki temel özellikleri sağlar:
- Eşzamanlılık Yönetimi
- Sürüm oluşturma
- Senkronizasyon
Bu özelliklerin her birini daha ayrıntılı olarak inceleyelim.
Eşzamanlılık Yönetimi
Eşzamanlılık, bir dosyanın birden fazla kişi tarafından aynı anda düzenlenmesini ifade eder. Büyük bir depoyla, insanların bunu yapabilmesini istiyoruz ancak bazı problemlere yol açabilir.
Mühendislik alanında basit bir örnek düşünün: Mühendislerin, merkezi bir kaynak kod deposunda aynı dosyayı aynı anda değiştirmelerine izin verildiğini varsayalım. Client1 ve Client2'nin bir dosyada aynı anda değişiklik yapması gerekir:
- Client1, bar.cpp'yi açar.
- Client2, bar.cpp'yi açar.
- Client1, dosyayı değiştirir ve kaydeder.
- Client2 dosyayı değiştirir ve İstemci1'deki değişikliklerin üzerine yazar.
Elbette böyle olmasını istemeyiz. Durumu müşterinin istediği gibi iki mühendisin doğrudan bir ana kopya yerine ayrı kopyalar üzerinde çalışmasını (aşağıdaki çizimde olduğu gibi) içeren kopyalar arasında bir şekilde mutabık kalınmalıdır. En sık SCM sistemleri, bu sorunu birden çok mühendisin bir dosyayı kontrol etmesine olanak tanıyarak "senkronize edin" veya "güncelleyin") ve gereken değişiklikleri yapın. SCM sonra sistem, dosyalar yeniden girilirken değişiklikleri birleştirmek için algoritmalar çalıştırır. ("gönder" veya "taahhüt").
Bu algoritmalar basit olabilir (mühendislerden çelişen değişiklikleri çözmelerini isteyin) veya o kadar basit değil (çakışan değişikliklerin akıllı bir şekilde nasıl birleştirileceğini belirleyin) ve sadece sistem gerçekten takılıp kalırsa bir mühendise sorun).
Sürüm oluşturma
Sürüm oluşturma, dosya düzeltmelerini takip etme anlamına gelir. Böylece dosyanın önceki bir sürümünü yeniden oluşturabilir (veya bu sürüme geri dönebilirsiniz). Bu işlem, depoda kontrol edildiğinde her dosyanın bir arşiv kopyasını oluşturarak, dosya üzerinde yapılan her değişikliği kaydederek uygulamanıza yardımcı olabilir. Arşivleri istediğimiz zaman veya bilgileri değiştirerek önceki sürümü oluşturun. Sürüm oluşturma sistemleri, Değişikliklere kimlerin giriş yaptığı, bu kişilerin ne zaman giriş yaptığı ve nelerin fark ettim.
Senkronizasyon
Bazı SCM sistemlerinde, dosyalar depoya tek tek girilir ve depodan çıkar. Daha güçlü sistemler, tek seferde birden çok dosyayı kontrol etmenize olanak tanır. Mühendisler depolarının kendi, eksiksiz, kopyalarını (veya bir kısmını) görebilmelerini gerektiği gibi kontrol edin. Daha sonra değişikliklerini ana depoya geri uygularlar ve değişikliklerden haberdar olmak için kendi kişisel kopyalarını güncelliyorlar yardımcı olduğunu söylüyor. Bu işleme senkronizasyon veya güncelleme adı verilir.
Alt değiştirme
Subversion (SVN), açık kaynaklı bir sürüm kontrol sistemidir. Sahip olduğu tüm özellikleri özellikleri kullanılabilir.
SVN, çakışmalar olduğunda basit bir metodoloji uygular. Çatışma iki zaman veya daha fazla mühendis, kod tabanının aynı alanında farklı değişiklikler yapar ve ardından her ikisi de değişikliklerini gönderir. SVN, yalnızca mühendislere bir sorun bu sorunun çözümü mühendislere kalmıştır.
Bu kurs boyunca SVN'yi kullanarak yapılandırma yönetimi. Bu tür sistemler sektörde çok yaygındır.
İlk adım, SVN'yi sisteminize yüklemektir. Sonraki slayta geçin burada bakın. İşletim sisteminizi bulun ve uygun ikili programı indirin.
Bazı SVN Terminolojileri
- Düzeltme: Bir dosya veya dosya grubunda yapılan değişiklik. Düzeltme, "anlık görüntü" her projede rol üstlenebilirsiniz.
- Depo: SVN'nin bir projenin tüm düzeltme geçmişini depoladığı ana kopya. Her projenin bir deposu vardır.
- Çalışma Kopyası: Mühendisin bir projede değişiklik yaptığı metin. Belirli bir projenin her biri ayrı bir mühendise ait olan birçok çalışma kopyası olabilir.
- Çıkış Yap: Depodan çalışan bir kopya istemek için. Çalışan bir kopya projenin satın alındığı sıradaki durumuna eşittir.
- Kaydetme: Çalışma kopyanızdaki değişiklikleri merkezi depoya göndermek için. Giriş veya gönderme olarak da bilinir.
- Güncelleme: Diğer kullanıcıların depodaki değişikliklerini çalışma kopyanıza getirmek veya çalışma kopyanızda henüz kaydetmediğiniz değişiklikler olup olmadığını belirtmek için Bu, yukarıda açıklandığı gibi senkronizasyonla aynıdır. Güncelleme/senkronizasyon, çalışan bir kopyanızı getirir güncel bilgileri girin.
- Çakışma: İki mühendisin bir dosyanın aynı alanında değişiklik yapmaya çalıştığı durumdur. SVN, çakışmaları belirtir ancak mühendislerin bunları çözmesi gerekir.
- Günlük mesajı: Bir düzeltmeyi kaydettiğinizde eklediğiniz yorumdur. ifadesini kullanın. Günlük, projede neler olduğuna dair bir özet sunar.
SVN'yi yüklediğinize göre şimdi bazı temel komutları inceleyeceğiz. İlgili içeriği oluşturmak için kullanılan ilk yapılması gereken, belirtilen bir dizinde depo oluşturmaktır. İşte komutları:
$ svnadmin create /usr/local/svn/newrepos $ svn import mytree file:///usr/local/svn/newrepos/project -m "Initial import" Adding mytree/foo.c Adding mytree/bar.c Adding mytree/subdir Adding mytree/subdir/foobar.h Committed revision 1.
import komutu, mytree dizininin içeriğini dizin projesi belirler. Şuradaki dizine göz atabiliriz: depoyu list komutuyla
$ svn list file:///usr/local/svn/newrepos/project bar.c foo.c subdir/
İçe aktarma işlemi, çalışan bir kopya oluşturmaz. Bunun için svn kullanmanız gerekir: ödeme komutunu kullanın. Bu işlem, dizin ağacının çalışan bir kopyasını oluşturur. Hadi yapın:
$ svn checkout file:///usr/local/svn/newrepos/project A foo.c A bar.c A subdir A subdir/foobar.h … Checked out revision 215.
Çalışan bir kopyanız olduğuna göre, bu dosya ve dizinlerde değişiklik yapabilirsiniz. Çalışma kopyanız, diğer dosya ve dizin koleksiyonları gibidir. Yeni dosya ve dizinler ekleyebilir, mevcut dosyaları düzenleyebilir, taşıyabilir ve hatta çalışma kopyasının tamamını silebilirsiniz. Çalışan kopyanızdaki dosyaları kopyalayıp taşırsanız yerine svn kopyası ve svn taşıma kullanmanız önemlidir. işletim sistemi komutlarını kullanabilirsiniz. Yeni bir dosya eklemek için svn add kullanın ve dosyayı silmek için svn delete dosyası kullanın. Sadece düzenlemek istiyorsanız dosyanızı düzenleyicinizle birlikte düzenleyebilirsiniz.
Genellikle Subversion ile birlikte kullanılan bazı standart dizin adları vardır. "Gövde" dizin projenizin ana geliştirme hattına sahiptir. Bir "dallar" dizin üzerinde çalıştığınız dal sürümünü içerir.
$ svn list file:///usr/local/svn/repos /trunk /branches
Diyelim ki çalışma kopyanızda gerekli tüm değişiklikleri yaptınız ve depoyla senkronize etmek istiyorsunuz. Projede çalışan çok sayıda başka mühendis çalışma metinlerinizi güncel tutmanız önemlidir. Yaşadığınız değişiklikleri görmek için svn status komutunu kullanabilirsiniz yapar.
A subdir/new.h # file is scheduled for addition D subdir/old.c # file is scheduled for deletion M bar.c # the content in bar.c has local modifications
Bu çıkışı kontrol etmek için durum komutunda çok sayıda işaret olduğunu unutmayın. Değiştirilmiş bir dosyadaki belirli değişiklikleri görüntülemek isterseniz svn diff aracını kullanın.
$ svn diff bar.c
Index: bar.c
===================================================================
--- bar.c (revision 5)
+++ bar.c (working copy)
## -1,18 +1,19 ##
+#include
+#include
int main(void) {
- int temp_var;
+ int new_var;
...
Son olarak, çalışan kopyanızı depodan güncellemek için svn update komutunu kullanın.
$ svn update U foo.c U bar.c G subdir/foobar.h C subdir/new.h Updated to revision 2.
Bu, anlaşmazlığın yaşanabileceği yerlerden biridir. Yukarıdaki çıkışta "U" harfi şunu gösterir: Bu dosyaların depo sürümlerinde herhangi bir değişiklik yapılmadı ve güncelleme yapıldı tamamlandı. "G" birleşmenin gerçekleştiği anlamına gelir. Depo sürümünde değiştirildi, ancak değişiklikler sizinkiyle çakışmadı. "C" şunu gösterir: bir çatışmaya neden olabilir. Bu, depodaki değişikliklerin sizinkiyle çakıştığı anlamına gelir. Şimdi ikisi arasında bir seçim yapmanız gerekiyor.
Subversion, çakışması olan her dosya için kopyala:
- file.mine: Bu dosya, sizden önceki çalışma kopyanızda bulunduğu haliyle çalışan kopyanızı güncelledi.
- file.rOLDREV: Bu, yapmanız gerektiğini unutmayın.
- file.rNEWREV: Bu dosya, depodaki geçerli sürümdür.
Çakışmayı çözmek için üç seçenekten birini tercih edebilirsiniz:
- Dosyaları gözden geçirin ve birleştirme işlemini manuel olarak yapın.
- SVN tarafından oluşturulan geçici dosyalardan birini çalışan kopya sürümünüzün üzerine kopyalayın.
- Tüm değişikliklerinizi iptal etmek için svn refund komutunu çalıştırın.
Çakışmayı çözdükten sonra svn resolved komutunu çalıştırarak SVN'ye bildirin. Bu işlem üç geçici dosyayı kaldırır ve SVN artık dosyayı bir çakışma durumunu gösterir.
Yapmanız gereken son şey, nihai sürümünüzü depoya kaydetmektir. Bu svn record komutuyla yapılır. Bir değişiklik yaptığınızda kullanarak değişikliklerinizi açıklayan bir günlük mesajı gönderin. Bu günlük mesajı, oluşturduğunuz düzeltmeye eklenir.
svn commit -m "Update files to include new headers."
SVN ve büyük yazılımları nasıl destekleyebileceği hakkında öğrenecek çok şey var mühendislik projeleri. Web'de çok sayıda kaynak mevcuttur. "Subversion" için Google araması yapmanız yeterlidir.
Alıştırma yapmak için Composer veritabanı sisteminiz için bir depolama alanı oluşturun ve tüm dosyalarınızı içe aktarın. Ardından çalışan bir kopyaya ödeme yapın ve açıklanan komutları uygulayın bölümünü ziyaret edin.
Referanslar
SVN ile ilgili Wikipedia makalesi
Uygulama: Anatomide Bir Çalışma
Üniversitedeki eSkeletons'a göz atın Teksas at Austin