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 ayrıştırma, işaretçileri anlama ve nesneler ile sınıflarla ilgili daha fazla alıştırma yapma konularına odaklanıyoruz. Aşağıdaki örnekleri inceleyin. Sorulduğunda programları kendiniz yazın veya deneyleri 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 bir mesafe için düşman mesafesini tanımlamak üzere rastgele bir sayı oluşturma aracına ihtiyacımız var yuvarlayın. 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, reklamlarımızı kaç vuruş yapıldığını ve kaç tane düşmanımızın olduğunu birkaç isabet alır. 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 fonksiyonda düşmanın mesafesini almak için rastgele bir sayı oluşturma aracı ve ardından döngüyü oyuncunun girdisini alıp düşmana vurup vurmadıklarını hesaplayın. İlgili içeriği oluşturmak için kullanılan döngüdeki nöbetçi koşulu, düşmana vurmaya ne kadar yaklaştığımızı belirtir.
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, matematik.h. Dene Bu programı yazmanın önemi, problemi çözme açısından harika bir uygulamadır. temel C++ incelemesi. Her işlevde yalnızca bir görev yapmayı unutmayın. Bu, bu nedenle biraz zaman alabilir, zamanı geldi.Çö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. Program yürütülürken
Tüm değişkenler, her biri kendi benzersiz adresinde veya konumunda olacak şekilde bellekte depolanır.
İşaretçi, alan adı 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. Aşağıda bununla ilgili bir örnek verilmiştir:
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") Yukarıdaki örnekte, intptr, noktanın
5.c
"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 başvuruyu 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ğlıyor.
Dolayısıyla y = x; y'yi, x ile aynı işaretçiyi işaret eder. İş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 atandıktan sonra iki işaretçi "paylaşıyor". "the"
Pointee'ye dokunun.
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 izini aşağıda görebilirsiniz:
| 1. x ve y şeklinde iki işaretçi ayırın. İşaretçileri ayırmak herhangi bir işaretçi ayırmaz. |  |
| 2. Bir işaretçi ayırın ve işaret olarak x'i 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'ü depolamaya ç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, bu yığını, çalışan programların kullanabileceği boş bir bellek deposu olarak düşünebilirsiniz.
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ısını 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ı girdi olarak alan Speed() adlı bir işlev ve bir miktar 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.
... adında tanımlayıcı fonksiyon, sabit ve değişken adları bulunur.
... 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. Ayrıca resmî bir belge olduğu gibi bir sayının mükemmel bir sayı olup olmadığını belirlemek için döngüleri kullanarak kare veya bir dizinin toplamıdır. (Not: Makinenize ve programınıza bağlı olarak, ancak bu numarayı bulmak oldukça uzun sürebilir.)
- 2. alıştırma
Ü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ı ifade eder. 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ındaki tüm bestecileri görüntüleme olanağı
- Tüm bestecileri rütbeye göre görüntüleme olanağı
“Bir projeyi yönetmenin iki yolu var: bir yol, müşterilerin açık bir şekilde açıkça görülebilecekleri hiçbir eksiklik yok, diğer yol da bunu çok karmaşık hale getirmek. herhangi bir eksiklik yoktur. İ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. Biz bir problemin çözümünü görevlere ayırır ve her biri projedeki problemin düşünmeye başlamışsınızdır. Bu görevler, programımızdaki sıralı olarak adlandırılan fonksiyonlarla eşlenir. işlevinden emin olun. Bu adım adım yaklaşım bazı düşünmemiz gerekiyor. Ama çoğu zaman programlarımız doğrusal programlardan ibaret değildir. etkinlik veya görev dizisidir.
Nesne odaklı (OO) bir yaklaşımla, "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 kullanıcıların bu hususa 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ı belirleme ve her sınıfın nesnesinin ne olduğunu genel olarak tanımlama neler yapabileceğini ve neler yapılabileceğini anlayabilirsiniz.
- 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ıf, yani kullanıcı arayüzü henüz görünecek gibi görünüyor, ancak bir taneye ihtiyacımız olacağını 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. Aynı zamanda manipüle etmeye yönelik yöntemler içerir. 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şılabiliyorsa ve özellikleri ile eylemleri netse olduğu gibi sınıfları tasarlamak da 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_;
};
Veritabanı sınıfı da kolaydır.
// 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 Google Hesabı'nda 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ı mı yoksa az nesnel mi olduğunuzu 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. Yaygın bir bu amaç için kullanılan gösterim UML (Birleşik Modelleme Dili) Artık Composer ve Database nesneleri için tanımlanmış sınıflarımız olduğuna göre Kullanıcının veritabanıyla etkileşim kurmasına olanak tanıyan bir arayüzdür. 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, bir veri analisti veya bir dizi 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 burada çok daha çıktıyı manuel olarak inceleyerek programın doğru çalıştığından emin olun. 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ı. Bir sonraki adım, için .cpp dosyalarını dahil edin.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 aralıkta olmalıdır. 1-10. 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 zor ve bariz değilse) belgelememelidir. 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ünya'ya hoş geldiniz!
Bu modülde, yazılım mühendisliğinin çoğunda kullanılan çok önemli iki aracı tanıtacağız. kuruluşlar. İlki derleme aracıdır, ikincisi ise bahsedeceğim. 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 yol sağlama ve birçok program ve başlık dosyasından bir sisteme bağlanıyor.
Yapma dosyaları
Program oluşturma süreci genellikle ve gerekli dosyaları doğru sırayla bağlar. Çoğu zaman C++ dosyalarında bağımlılıklar, örneğin, bir programda çağrılan bir işlev, başka bir programda çok önemli. Ya da birkaç farklı .cpp dosyası için bir başlık dosyasına ihtiyaç duyulabilir. CEVAP derleme aracı bu bağımlılıklardan doğru derleme sırasını belirler. Bu yalnızca son derlemeden sonra değişen dosyaları da derleyin. Bu, 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. Daha fazla bilgi edinmek için bununla makalesini inceleyin. 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, Ali ve Susan'ın erişebileceği bir bilgisayarda saklanı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, çalışma hızını yavaşlatır önemli ölçüde azalttı.
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 "ödeme" 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, açıklandığı gibi eşzamanlı değişiklikleri yönetmenin ötesinde bir dizi özelliğe sahiptir bölümünü ziyaret edin. Birçok sistem, dokümanın ilk sürümünden itibaren geçerli olmak üzere, bir dokümanın tüm sürümlerinin oluşturulduğu zamanı ifade eder. 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. Bir CM sistemi, teknoloji yazarının eski sürüme erişmesine ve Böylece kullanıcının gördüklerini görebilirsiniz.
CM sistemleri özellikle yazılımda yapılan değişikliklerin kontrol edilmesinde yararlıdır. Böyle sistemlerine Yazılım Yapılandırma 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ırması 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
Şimdi bu özelliklerin her birini daha ayrıntılı bir şekilde 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 örneği ele alalım: Mühendislerin merkezi bir kaynak kodu deposunda aynı dosyayı değiştirmelerine olanak tanır. 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. Orada bir projenin, her biri ayrı bir mühendise ait çalışan birçok kopya 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 çalışan kopyanıza dönüştürürseniz, veya çalışan kopyanızda kaydedilmemiş değişiklikler olup olmadığını belirtebilirsiniz. Bu, yukarıda açıklandığı gibi senkronizasyonla aynıdır. Güncelleme/senkronizasyon, çalışan bir kopyanızı getirir güncel bilgileri girin.
- Çatışma: İki mühendisin aynı metinde değişiklik yapmaya çalışması alanına yerleştirilebilir. 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, olup bitenleri içeren bir özet bilmek kadar harika bir his yok.
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.
İçe aktarma 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 artık dosyalarda ve dizinlerde değişiklik yapabilirsiniz. inceleyeceğiz. Çalışan kopyanız diğer dosya ve dizin koleksiyonları gibidir Yenilerini ekleyebilir, düzenleyebilir, taşıyabilir, hatta silebilirsiniz eksiksiz bir şekilde hazırlar. Ç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 tür bir anlaşmazlık söz konusu olabilir. 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 bulunan ç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ı gidermek için aşağıdaki üç işlemden birini yapabilirsiniz:
- 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 çözümlendi komutunu çalıştırarak SVN'ye durumu bildirirsiniz. 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ı eklendi düzeltmeyi öğreneceksiniz.
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 pek çok kaynak bulunmaktadır. "Subversion" ile ilgili bir Google araması yapalım.
Pratik yapmak için Composer Database sisteminiz için depo oluşturup içe aktarın. tüm dosyalarınız. 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, Austin