Issue 67325: Cannot update from ADT 22.3.0. to 22.6.1

Resim

Please follow these steps:
1. Help | Install new software
2. Select the ADT update site (there are two, one with http:// and one with https:// If one doesn't work, try the other.
3. Select the developer tools section and press next.
4. You should see a dialog that says "this software is already installed, an update will be performed instead". Clicking ok will lead to 22.6.1 being installed.

What is functional and non functional requirement ?

Resim

A functional requirement describes what a software system should do, while non-functional requirements place constraints on how the system will do so.

FUNCTIONAL REQUIREMENTS the activities the system must perform

  • business uses functions the users carry out
  • use cases example if you are developing a payroll system required functions
  • generate electronic fund transfers
  • calculation commission amounts
  • calculate payroll taxes
  • report tax deduction to the IRS
    Let me elaborate.

An example of a functional requirement would be that a system must send a an email whenever a certain condition is met (e.g. an order is placed, a customer signs up, etc).

A related non-functional requirement for the system may be that emails should be sent with a latency of no greater than 12 hours from such an activity.

The functional requirement is describing the behavior of the system as it relates to the system’s functionality. The non-functional requirement elaborates a performance characteristic of the system.

Typically non-functional requirements fall into areas such as:

  • Accessibility
  • Capacity, current and forecast
  • Compliance
  • Documentation
  • Disaster recovery
  • Efficiency
  • Effectiveness
  • Extensibility
  • Fault tolerance
  • Interoperability
  • Maintainability
  • Privacy
  • Portability
  • Quality
  • Reliability
  • Resilience
  • Response time
  • Robustness
  • Scalability
  • Security
  • Stability
  • Supportability
  • Testability

A more complete list is available at Wikipedia’s entry for non-functional requirements.

Non-functional requirements are sometimes defined in terms of metrics (something that can be measured about the system) to make them more tangible. Non-functional requirements may also describe aspects of the system that don’t relate to it’s execution, but rather to it’s evolution over time (e.g. maintainability, extensibility, documentation, etc).

C++ Overloading Functions

C++ dilinde parametrik yapısı birden farklı olması kaydıyla oluşturulan aynı isimdeki fonksiyonlara overloading function denir.

Örnek olarak şöyle bir örnek yazabiliriz. Düşününki elinizde aynı işlevi yapan bir fonksiyonunuz var. Bu fonksiyonun ana görevi “yazmak” olsun. Fakat yazıcağı ifadenin veri türü farklı olduğunu varsayalım. Bunun gibi durumlarda ihtiyaç duyulan iki tane fonksiyon tanımlamıyoruzda aynı isimde farklı işler yapabilicek fonksiyon yazıyoruz. Yani demek istediğim aslında yazdırma işlemi operasyonu tek elden çıkarmak istememiz. Aksi taktirde sen printOnlyFloat()  yada printOnlyInt() gibi farklı adlarda fonksiyonlar tanımlamak zorunda kalıcaksın. Buda senin belleğinden daha çok hafızaya yer açılması demektir. Programları yazarken Memory Management düşünmek her zaman için iyidir.

#include <iostream>
using namespace std;

// describing overloading function as you like,

void printNumber(int v) { // first function
cout <<i am printing an integer<< x << endl;
}

void printNumber(float v) { //second function
cout << i am printing an integer<< x << endl;
}

int main(){

int a =54;
float b=32.4896;

printNumber(a); //first function writes integer number
printNumber(b); //second function writes float number

}

Bu haftadaki yazımız sona ermiştir. Tekrar görüşmek dileğiyle…

Struct ve Pointer Kullanımı Örnek

#include “stdafx.h”
#include “iostream”

struct futbolTakim {
char * takimIsim;
int kurulusYili;
int oynadigiLig;
int ligSirasi;
int sampiyonlukSayisi;
};

int main(){

struct futbolTakim a;
struct futbolTakim *b;

b=&a;

(*b).takimIsim=”besiktas”;
(*b).kurulusYili=1903;
(*b).oynadigiLig=1;
(*b).ligSirasi=1;
(*b).sampiyonlukSayisi=11;

// simdi bu bilgileri ekrana yazdiralim:

cout<< “takim isim:”    <<(*b).takimIsim;
cout<< “kurulus yili:   <<(*b).kurulusYili;
cout<< “oynadigi lig:” <<(*b).oynadigiLig;
cout<< “lig sirasi:”        <<(*b).ligSirasi);
cout<< “sampiyonluk sayisi: ” << (*b).sampiyonlukSayisi);

return 0;
}

Yığın (Stack)

Eleman ekleme çıkarmaların en üstten (top) yapıldığı veri

yapısına yığın (stack) adı verilir. Bir eleman ekleneceğinde

yığının en üstüne konulur. Bir eleman çıkarılacağı zaman

yığının en üstündeki eleman çıkarılır. Bu eleman da yığındaki

elemanlar içindeki en son eklenen elemandır. Bu nedenle

yığınlara LIFO (Last In First Out : Son giren ilk çıkar) listesi

de denilir. C#’ta Yığın yapısı hazır olarak vardır :

(Koleksiyon sınıflarından) Stack sınıfının bazı metotları

  • Push : Yığına (sonuna) eleman ekleyen metot.
  • Pop : Yığıntan (sonundan) eleman silen metot.
  • Eleman ekleme çıkarmaların en üstten (top) yapıldığı veri yapısına yığın (stack) adı verilir.
  • Bir eleman ekleneceğinde yığının en üstüne konulur.
  • Bir eleman çıkarılacağı zaman yığının en üstündeki eleman çıkarılır.
  • Bu eleman da yığıntaki elemanlar içindeki en son eklenen elemandır.
  • Bu nedenle yığınlara LIFO (Last In First Out : Son giren ilk çıkar) listesi de denilir.Yığın Gösterimi
  • (Tanım) Boş yığın (empty stack) : Elemanı olmayan yığın.
  • push (yığına eleman ekleme) : “push(s,i)”, s yığınının en üstüne i değerini eleman olarak ekler.
  • pop (yığıntan eleman çıkarma) : “i = pop(s)”, s yığınının en üstündeki elemanı çıkartır ve değerini i değişkenine atar.
  • empty (yığının boş olup olmadığını belirleyen işlem) : empty(s), yığın boş ise TRUE değerini, değilse FALSE değerini döndürür.
  • stacktop (yığıntan çıkarılmaksızın en üstteki elemanın değerini döndüren işlem, diğer adı peek)
Örnek:
#include “stdafx.h”
#include <iostream>
using namespace std;

#define MAXSIZE 5
//typedef int tam;
struct ornek
{
int dizi[MAXSIZE];// yıgın
int top;          // yıgın indis değişkeni
};
typedef struct ornek orn;
void initStack(orn *p);
void push (orn *p, int yeni_deger);
int pop(orn *p);
int isEmpty(orn *p);
int top(orn ust);
int main()
{
orn a;
int k,i;
initStack(&a);
push(&a,17);
push(&a, 29);
push(&a, 37);
push(&a,49);
for(i=0; i<5; i++)
{
k = pop(&a);
cout << “cıkartılan deger :” << k << endl;
}
for(i=0; i<9; i++)
{
push(&a,i);

}
cin.get();
}

void initStack(orn *p)
{
p->top = -1;
}

void push(orn *p, int yeni_deger)
{
if (isEmpty(p))
{
p->top = p->top + 1;
p->dizi[p->top]= yeni_deger;
}
else cout << “stack dolu\n”;

}

int isEmpty(orn *p)
{
if(p ->top == MAXSIZE)return 0;
return 1;
}

int pop(orn *p)
{
int k;
if (p->top != -1)
{
k = p->dizi[p->top];
(p->top)–;
}
else cout << “stack boş\n”;
return k;
}

int top(orn ust)
{
return ust.dizi[ust.top];
}
/*
int top(orn *ust)
{
return ust->dizi[ust->top];
}  */

Kuyruklar (Queues)

  • Bu bölümde gerçek yaşamdaki kuyrukların bilgisayardaki gösterimleri üzerinde durulacaktır.
  • Kuyruklar, eleman eklemelerin sondan (rear) ve eleman çıkarmaların baştan (front) yapıldığı veri yapılarıdır.
  • Bir eleman ekleneceği zaman kuyruğun sonuna eklenir.
  • Bir eleman çıkarılacağı zaman kuyrukta bulunan ilk eleman çıkarılır.
  • Bu eleman da kuyruktaki elemanlar içinde ilk eklenen elemandır.
  • Bu nedenle kuyruklara FIFO (First-In First-Out = ilk giren ilk çıkar) listeleri de denilmektedir.
  • Gerçek yaşamda da bankalarda, duraklarda, gişelerde, süpermarketlerde, otoyollarda kuyruklar oluşmaktadır.
  • Kuyruğa ilk olarak girenler işlemlerini ilk olarak tamamlayıp kuyruktan çıkarlar.
  • Veri yapılarındaki kuyruklar bu tür veri yapılarının simülasyonunda  kullanılmaktadır.
  • Ayrıca işlemci, yazıcı, disk gibi kaynaklar üzerindeki işlemlerin yürütülmesinde ve bilgisayar ağlarında paketlerin yönlendirilmesinde de kuyruklardan yararlanılmaktadır.
    #include “stdafx.h”
    #include <iostream>
    using namespace std;

    #define MAXSIZE 5
    //typedef int tam;
    struct ornek
    {
    int dizi[MAXSIZE];// kuyruk
    int on;           // kuyrukdan kim çıkacak indis değişkeni
    int arka;         // kuyruğa kim girecek indis değişkeni
    int say;          // kuyrukda kaç kişi var değişkeni
    };
    typedef struct ornek orn;
    void initQueue(orn *p);
    void insert (orn *p, int yeni_deger);
    int remove(orn *p);
    int isEmpty(orn *p);
    int main()
    {
    orn a;
    int i,k;
    initQueue(&a);

    insert(&a, 29);
    k = remove(&a);
    cout << ” cikan kisi = ” << k << endl;

    cout << ” on = ” << a.on << endl;
    cout << ” arka = ” << a.arka << endl;
    cout << ” say = ” << a.say << endl;

    cin.get();
    }// main sonu

    void initQueue(orn *p)
    {
    p->on , p->arka, p->say = 0;
    }

    void insert(orn *p, int yeni_deger)
    {
    if (p->say != MAXSIZE)
    {
    p->dizi[p->arka] = yeni_deger;
    p->arka = (p->arka +1) % MAXSIZE;
    p->say = p->say + 1;
    }
    else cout << “kuyruk dolu\n”;

    }// insert sonu

    int isEmpty(orn p)
    {
    if(p.say == 0 )return 1;
    return 0;
    }//is Empty sonu

    int remove(orn *p)
    {
    int k = 0;
    if (p->say != 0)
    {
    k = p->dizi[p->on];
    p->on = (p->on +1) % MAXSIZE;
    (p->say)–;
    }
    else cout << “kuyruk boş\n”;
    return k;
    }// remove sonu

Tek Yönlü Bağlı Listeler

Bir liste elemanı kendi değerinin yanında bir de sonraki elemana işaret eden bir adres değişkeni içeren bir karmaşık değişken olarak tanımlanmış olmalıdır. C++ dilinde tamsayı değerli bir bağlantılı liste elemanı “struct” adı verilen değişken yapısıyla aşağıdaki gibi tanımlanabilir:

struct eleman
{
int Deger;
struct eleman *pSonraki;
}

#include “stdafx.h”
#include <iostream>
using namespace std;

struct liste
{
int bilgi;
struct liste *link;
};
typedef struct liste list;
list * liste Baslat(int bilgi);
list * elemanOlustur(int yeni_bilgi);
int listeUzunlugu(list *p);
list * basaEkle(list *p, list * yeni_eleman);
void * sonaEkle(list *p, list * yeni_eleman);
void * arayaEkle(list *p, list * yeni_eleman);
void * arayaEkle(list *p, list * yeni_eleman);
list * elemanCıkar(list *p, list * cikan_eleman);
int listeBosMu(list *p);
list * iElemanBul(list *p, int i);
int main()
{

cin.get();
}// main sonu

list * liste Baslat(int bilgi)
{
list *m = (list *)malloc(sizeof(list));
m->link = ”;
m->bilgi = bilgi;
return m;
} // listeBaslat sonu
int * listeUzunlugu(list *p)
{
int i = 1;
list *t = p;
if(t == ”)
{
cout << “Hata! Liste yok\n”;
return -32767;
}
while(t->link != ”)
{
i++;
t = t->link;
}
return i;
}//listeUzunlugu sonu

list * elemanOlustur(int yeni_bilgi)
{
list *eleman = (list *)malloc(sizeof(list));
eleman->bilgi = yeni_bilgi;
eleman->link = ”;
return eleman;
}// eleman olustur sonu
list * basaEkle(list *p, list * yeni_eleman)
{
if(p == ” || yeni_eleman == ”)
{
cout << “hata !! Liste ya da ekelenecek eleman yok\n”;
return p;
}
}// basa ekle sonu
list * sonaEkle(list *p, list * yeni_eleman)
{
list *t = p;
if(t == ” || yeni_eleman == ”)
{
cout << “hata !! Liste ya da ekelenecek eleman yok\n”;
}
else
{
while(t->link != ”)
{
t = t->link;
t->link = yeni_eleman;
}
}
return t;
}// sona ekle sonu
list * arayaEkle(list *p, list * yeni_eleman)
{
if(p == ” || yeni_eleman == ”)
{
cout << “hata !! elemanlardan biri tanımlı değil\n”;
}
else
{
yeni_eleman->link = p->link;
p->link = yeni_eleman;
}
}// araya ekle sonu
list * iElemanBul(list *p, int i)
{
int sira_no = 1;
list *t = p;
if(t == ”)
{
cout << “Hata! Liste tanımlı değil\n”;
return ”;
}
while(t->link != ”)
{
t = t->link;
t->link = yeni_eleman;
}
return t;
}// iElemanBul sonu
list * elemanCıkar(list *p, list * cikan_eleman)
{
list *t = p;
if(cikan_eleman == ” || t == ”)
cout << “Hata! Liste veya cıkacak eleman yok\n”;
else
{
if(t == cikan_eleman)
{
t = t->link;
return t;
}
else
{
while(t->link != cikan_eleman)
{
t = t->link;
if(t == ”)break;
}
if (t == ”)
{
cout << “cıkacak eleman listede yok\n”;
return p;
}
if(t->link == cikan_eleman)
{
t->link = cikan_eleman->link;
free(cikan_eleman);
return p;
}
}
}
}

Struct ve Göstericiler Kullanımı

// struct.cpp : main project file.

#include “stdafx.h”
#include “iostream”
using namespace std;

typedef struct yapi{

int adres;
char adi[25];

}adres_bilgileri;

int main()
{
setlocale(LC_ALL,”Turkish”);
//struct yapi ankara;böylede kullanılabilir.
adres_bilgileri ankara;
adres_bilgileri izmir[3];
adres_bilgileri *ptr;

cout<<“Ankara üyesinin adres nosunu giriniz”;
cin>>ankara.adres;

for(int i=0;i<3;i++){
cout<<“izmir üyesinin adını giriniz”;
cin>>izmir[i].adi;
cout<<“İzmir üyesinin adres nosunu giriniz”;
cin>>izmir[i].adres;
}
izmir[3]=ankara;
ptr=izmir;

for(int i=0;i<3;i++){

cout<<“Adı:”<<ptr[i].adi<<“\n”;

cout<<“Adres:” <<ptr[i].adres<<“\n”;
}

return 0;
}