1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

CCalendar& CCalendar::operator+=(const CCalendarEntry& entry) {
	CCalendarEntry *newEntries = new CCalendarEntry[m_numberOfEntries + 1]();

// ab hier dann das Umkopieren der alten Entries und richtige Einfügen des neuen Entry
// hier also noch ganz viel Code, der die eigentliche Arbeit erledigt

	if(m_entries != nullptr)
		delete[] m_entries;
	++m_numberOfEntries;
	m_entries = newEntries;
	return *this;
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

#ifndef MYCODE_CCALENDAR_H_
#define MYCODE_CCALENDAR_H_

#include "CCalendarEntry.h"
#include "CJulianDate.h"

class CCalendar {
  private:
	CCalendarEntry *m_entries = nullptr;
	unsigned int m_numberOfEntries = 0;

  public:
	CCalendar();
	~CCalendar();

	CCalendar &operator+=(const CCalendarEntry& entry);
	void print() const;
	void print(const CJulianDate& from) const;
};

#endif /* MYCODE_CCALENDAR_H_ */

1:
2:
3:
4:
5:
6:
7:

if( m_entries> newEntries){

m_entries == newEntries;

return *this;
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

for( m_numberofEntries= 0 ;  m_numberofEntries>0; m_numberofEntries++) {
if( m_entries> newEntries){

m_entries = newEntries;

return *this;
}

}

1:

for(int i = 0; i < m_numberOfEntries; i++) {...}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

Calendar& operator+=(const CCalendarEntry& entry){

	CCalendarEntry * oldEntries = m_entries;  // das alte Array
	CCalenderEntry * newEntries = new CCalendarEntry [m_numberofEntries + 1];
	m_entries = newEntries;  // m_entries auf das neue Array zeigen lassen
	delete [] oldEntries;  // das alte Array zerlegen
	for(unsigned int i = 0; i < m_numberOfEntries; i++) {

	if(m_date> CCalendarEntry [m_numberofEntries + 1]){
		weiter immer noch keine Ahnung ?
				
				Ein kleiner tipp nochmals?
		
		


	}
	}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:

#include "CCalendar.h"
#include "CCalendarEntry.h"
#include "CJulianDate.h"

CCalendar::CCalendar(){}
CCalendar::~CCalendar() {
	if(m_entries != nullptr)
		delete[] m_entries;
}

CCalendar& CCalendar::operator+=(const CCalendarEntry& entry) {
	CCalendarEntry *newEntries = new CCalendarEntry[m_numberOfEntries + 1]();
	bool alreadyInserted = false;
	for(unsigned int i = 0; i < m_numberOfEntries; i++) {
		if(!alreadyInserted && (entry.getDate() < m_entries[i].getDate())) {
			newEntries[i] = entry;
			alreadyInserted = true;
		}
		newEntries[alreadyInserted ? i + 1 : i] = m_entries[i];
	}
	if(!alreadyInserted)
		newEntries[m_numberOfEntries] = entry;

	if(m_entries != nullptr)
		delete[] m_entries;
	++m_numberOfEntries;
	m_entries = newEntries;
	return *this;
}

void CCalendar::print() const{
	cout << "Einträge im Kalender:" << endl;
	for(unsigned int i = 0; i < m_numberOfEntries; i++) {
		m_entries[i].print();
	}
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

Calendar& operator+=(const CCalendarEntry& entry){

    CCalendarEntry * oldEntries = m_entries;  // das alte Array
    CCalenderEntry * newEntries = new CCalendarEntry [m_numberofEntries + 1];
    m_entries = newEntries;  // m_entries auf das neue Array zeigen lassen
    delete [] oldEntries;  // das alte Array zerlegen
    for(unsigned int i = 0; i < m_numberOfEntries; i++) {

    if( CCalendarEntry [i]   >CCalendarEntry [i+ 1]){
        
        CCalendarEntry [i] = CCalendarEntry [i+ 1];
        
        CCalendarEntry [i+ 1]= new Entries;




    }
m_entries = newEntries;  // m_entries auf das neue Array zeigen lassen
    delete [] oldEntries;  // das alte Array zerlegen

    } 

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

Calendar& operator+=(const CCalendarEntry& entry){

	
	CCalendarEntry * newEntries = new CCalendarEntry [m_numberofEntries + 1];
	unsigned int i,temp,j,m_numberofSize;
	for(i=1; i<m_numberofSize; i++){
		
		temp = CCalendarEntry[i];
		j= i-1;
		while(j>=0 && CCalendarEntry[j]< temp){
			CCalendarEntry[j+1] = CCalendarEntry[j];
			j--;
			
		}
		CCalendarEntry[j+1]= temp;
		}
		
	}



	}
	}

1:
2:
3:
4:

	newEntries[alreadyInserted ? i + 1 : i] = m_entries[i];

1:
2:
3:
4:
5:
6:

if(alreadeInserted)
    newEntries[i + 1] = m_entries[i];
else
    newEntries[i] = m_entries[i];

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

* CCalendar.cpp
 *
 *  Created on: 21.08.2017
 *      Author: vaio
 */

#include "CCalendar.h"




CCalendar::CCalendar() {


}

CCalendar::~CCalendar() {
	if( m_entries >=0 ){
	delete m_entries;
	}
}

Calendar& operator+=(const CCalendarEntry& entry){

	CCalendarEntry * oldEntries = m_entries; 
	CCalendarEntry * newEntries = new CCalendarEntry [m_numberofEntries + 1];
	
	for(i=1; i<m_numberofSize; i++){
		
		oldEntries[i] = newEntries[i];kopiere jedes einzelne Element vom m_entries Array in das neu angelegt Array um.
		newEntries [i] = newEntries[i+1]; Danach kopierst Du das übergebene entry an die letzte Stelle des neu angelegten Arrays, die ja noch frei sein muss, weil Du es ja um eins größer angelegt hattest.
		}
	m_entries = newEntries;  // m_entries auf das neue Array zeigen lassen
	    delete [] oldEntries;  // das alte Array zerlegen

	    } 

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:

* CCalendar.cpp
 *
 *  Created on: 21.08.2017
 *      Author: vaio
 */

#include "CCalendar.h"




CCalendar::CCalendar() {


}

CCalendar::~CCalendar() {
        if( m_entries >=0 ){
        delete m_entries;
        }
}

Calendar& operator+=(const CCalendarEntry& entry){

        CCalendarEntry * oldEntries = m_entries; 
        CCalendarEntry * newEntries = new CCalendarEntry [
  (m_numberOfEntries + 1) - 1   ];     
        for(i=0; i<m_numberofSize; i++){
                
                oldEntries[i] = entry;kopiere jedes einzelne Element vom m_entries Array in das neu angelegt Array um.
               
                }
         entry = newEntries[i+1]; D
        m_entries = newEntries;  // m_entries auf das neue Array zeigen lassen
            delete [] oldEntries;  // das alte Array zerlegen

            } 

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:

* CCalendar.cpp
 *
 *  Created on: 21.08.2017
 *      Author: vaio
 */

#include "CCalendar.h"




CCalendar::CCalendar() {


}

CCalendar::~CCalendar() {
        if( m_entries >=0 ){
        delete m_entries;
        }
}

Calendar& operator+=(const CCalendarEntry& entry){

        CCalendarEntry * oldEntries = m_entries; 
        CCalendarEntry * newEntries = new CCalendarEntry [
  (m_numberOfEntries + 1) - 1   ];     
        for(i=0; i<m_numberofSize; i++){
                f( (entry.getDate() < m_entries[i].getDate())) {
                        newEntries[i] = entry;
...........................................................................................
                        
                }

                oldEntries[i] = entry;kopiere jedes einzelne Element vom m_entries Array in das neu angelegt Array um.
               
                }
         entry = newEntries[i+1]; D
        m_entries = newEntries;  // m_entries auf das neue Array zeigen lassen
            delete [] oldEntries;  // das alte Array zerlegen

            } 

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:

* CCalendar.cpp
 *
 *  Created on: 21.08.2017
 *      Author: vaio
 */

#include "CCalendar.h"




CCalendar::CCalendar() {


}

CCalendar::~CCalendar() {
        if( m_entries >=0 ){
        delete m_entries;
        }
}

Calendar& operator+=(const CCalendarEntry& entry){

        CCalendarEntry * oldEntries = m_entries; 
        CCalendarEntry * newEntries = new CCalendarEntry [
  (m_numberOfEntries + 1) - 1   ];     
        for(i=0; i<m_numberofSize; i++){
                f( (entry.getDate() < m_entries[i].getDate())) {
                         entry = newEntries[i] ;
                        
                }

                oldEntries[i] = entry;kopiere jedes einzelne Element vom m_entries Array in das neu angelegt Array um.
               
                }
          newEntries[i+1]= entry ; D
        m_entries = newEntries;  // m_entries auf das neue Array zeigen lassen
            delete [] oldEntries;  // das alte Array zerlegen

            }