'C++'에 해당되는 글 7건
- 2010.08.16 다중 상속의 문제점
- 2010.08.13 C++ 생성자
- 2010.08.13 생성자와 소멸자
- 2010.07.03 c++ 오버라이딩
- 2010.06.14 동적 할당 0614
- 2010.06.10 c++ 0610
- 2010.06.08 c++0608
#다중 상속의 문제점
1. 상속받은 두 클래스에 같은 이름의 함수가 있을 경우, 어느 함수를 호출해야 할 지 알 수 없다.
>>어느 클래스의 함수인지 명시한다.
>>객체.부모클래스::멤버함수();
2. B가 A를 상속받고, C도 A를 상속 받은 후, D가 B와 C를 상속 받는 경우, A가 두 번 포함된다. (다이아몬드 상속)
>>B와 C가 A를 virtual 상속받는다.
>>class B : virtual public A {...}
>>class C : virtual public A {...}
>>class D : public B, public C {...}
D에서 A의 멤버 함수를 사용하려면 B::멤버 함수 또는 C::멤버 함수로 사용하여야 한다.
A::멤버 함수로는 사용할 수 없다. B와 C가 virtual로 A를 상속받았기 때문이다.
C++, pasted 1 second ago:
|
-end
'C++' 카테고리의 다른 글
| 다중 상속의 문제점 (0) | 2010.08.16 |
|---|---|
| 생성자와 소멸자 (0) | 2010.08.13 |
| c++ 오버라이딩 (0) | 2010.07.03 |
| 동적 할당 0614 (0) | 2010.06.14 |
| c++ 0610 (0) | 2010.06.10 |
생성자
클래스와 동일한 이름
반환 값이 없다.
객체가 생성될 때 자동으로 호출된다.
생성자를 작성하지 않으면 기본 생성자가 자동으로 호출된다. Class::Class() {}
Point::Point() { _x = 0; _y = 0; }
Point pt;
Point pt = Point();
디폴트 생성자
인자가 없는 생성자 Class::Class() { initialize code; }
Point pt;
Point pt = Point();
인자가 있는 생성자
Point::Point(int x, int y) {_x = x; _y = y; }
Point pt(10, 20);
복사 생성자
자신과 동일한 타입의 객체에 대한 레퍼런스를 인자로 받는 생성자.
Class::Class(Class& c) { intialize code; }
Class::Class(const Class& c) { intialize code; } 권장
Point::Point(const Point& pt) { x = pt.x; y = pt.y; }
Point pt1;
Point pt2 = pt1; (초기화 문법 이용)
Point pt2(pt1); (생성자 호출 문법 이용)
*초기화 : 생성과 동시에 값을 대입하는 것???
Point pt1;
Point pt2;
pt2 = pt1; 복사 생성자가 호출되지 않고, 멤버변수를 1:1로 복사한다.
class string
{
private:
char* p;
public:
string(const string& s);
int size() const
{
return strlen(p);
}
...
Shallow Copy
string::string(const string& s) { p = s.p; }
string str1;
string str2(str1);
str1 객체의 문자열의 시작 주소만 복사된다. str1 객체가 소멸되면 str1이 가리키고 있던 문자열도 소멸되므로 str2는???
Deep Copy
string::string(const string& s) { p = new char[s.Size() + 1]; strcpy(p, s.p);
string str1;
string str2(str1);
str1 객체의 문자열 자체를 복사한다. str1 객체가 소멸되어도 str2 객체는 새로 생성된 문자열의 시작주소를 가리키므로 문제없다.
반드시 생성자가 필요한 경우 : const, &
const : 한 번 정의된 이후에는 값을 변경할 수 없으므로 반드시 초기화하여 그 값만을 가져야 한다.
& : 처음 정의할 때 참조한 변수 이외의 다른 변수는 참조할 수 없으므로 반드시 초기화해야 한다.
class NeedConstructor
{
public:
const int maxCount;
int& ref;
int sample;
NeedConstructor();
NeedConstructor(int count, int& number);
};
NeedConstructor::NeedConstructor()
: maxCount(100), ref(sample)
{
sample = 200;
}
NeedConstructor::NeedConstructor(int count, int& number)
: maxCount(count), ref(number0
{
sample = 200;
}
생성자를 이용한 임시 객체
void Func(const Point& pt)
{
...
}
Func(Point(x, y));
소멸자
DynamicArray::DynamicArray(int arraySize)
{
arr = new int [arraySize];
arr = new int [arraySize];
}
DynamicArray::~DynamicArray()
{
delete [] arr;
arr = NULL;
}
main() 죵료시 함수 내의 객체도 소멸되므로 소멸자를 호출하고 이 때 메모리를 해제한다.
import android.view.View.oonclickelisterne;
setContentView(R.laout.hello_layout);
EditText edittext = (EditiText)this.findViewById(R.id.EditText01);
Button button = (button)this.findViewById(R.id....);
button.setonclickelistenter(new onclicklistener() {
} )
public onClick(View arg0) {
edittext.setText("버튼 눌러짐"); << final 처리 변수 -- final EditText edit~~~
'C++' 카테고리의 다른 글
| 다중 상속의 문제점 (0) | 2010.08.16 |
|---|---|
| C++ 생성자 (0) | 2010.08.13 |
| c++ 오버라이딩 (0) | 2010.07.03 |
| 동적 할당 0614 (0) | 2010.06.14 |
| c++ 0610 (0) | 2010.06.10 |
자식 클래스가 부모 클래스의 오버로드된 함수들 중 하나만 오버라이딩 하면 에러.
모든 함수를 오버라이딩하면 성공.
상속과 무관...
디폴트 생성자 없이 생성자를 만든 후, 그 생성자를 호출하면 에러.
디폴트 생성자 만들고 다른 생성자 만든 후, 그 생성자를 호출하면 성공.
C++
2차원 배열 동적 할당
int * ptr = new int; == int * ptr = new int [1];
*ptr == ptr[0] == *(ptr + 0)
ptr == &ptr[0] == &*(ptr + 0) == (ptr + 0)
int arr[2][3] = {1, 2, 3, 4, 5, 6};
2차원 배열이지만 실제 메모리 상에서는 1차원 배열이 연속적으로 나열되어 있다.
즉, 3칸짜리 배열 2개가 이어져 있는 경우이다.
머릿속 그림)
┏━┯━┯━┓
┃1│2│3┃
┣━┿━┿━┫
┃4│5│ 6┃
┗━┷━┷━┛
┏━┯━┯━┳━┯━┯━┓
┃1│2│3┃4│5│6┃
┗━┷━┷━┻━┷━┷━┛
실제 메모리)
┏━┯━┯━┳━┯━┯━┓
┃ 1│ 2│ 3┃ 4│ 5│ 6┃
┗━┷━┷━┻━┷━┷━┛
┌─┬─┬─┬─┬─┬─┐
│1│2│3│4│5│6│
└─┴─┴─┴─┴─┴─┘
┌─┬─┬─┬─┬─┬─┐
│1│2│3│4│5│6│
└─┴─┴─┴─┴─┴─┘
arr[0]과 arr[1]은 3칸짜리 배열의 이름이며, 시작주소가 된다.
따라서 타입은 int*가 된다.
arr은 3칸짜리 배열묶음이 2칸인 배열의 이름이며, 시작주소가 된다.
따라서 타입은 int(*)[3]이 된다.
int * ptr = new int[3];
int * * dptr = new int[3];
linux0610.zip
같은 이름의 함수를 여러 개 쓸 수 있다.
C는 함수의 이름으로만 심볼을 생성하기 때문에 동일한 이름의 함수를 사용할 수 없다.
C++는 함수의 이름에 시그니처(매개변수의 타입과 갯수, 리턴 타입은 포함되지 않음)에 대한 정보를 추가하여 심볼을 생성하기 때문에 동일한 이름의 함수를 사용할 수 있다.
오버로딩이 가능한 경우
1. 매개변수 갯수는 같지만 타입이 다른 경우
2. 매개변수 타입은 같지만 갯수가 다른 경우
오버로딩이 불가능한 경우
1. 두 함수의 매개변수가 각각 일반 자료형, 레퍼런스형인 경우 이 둘의 실인자의 구별이 불가능하다.
2. 두 함수의 리턴 타입만 다른 경우 이 둘의 실인자의 구별이 불가능하다.
함수 찾는 순서
1. Exact Match
2. Promotion
3. Standard Conversions
4. User-defined Conversions
#디폴트 인자
디폴트 인자는 항상 오른쪽부터 설정한다. 그래야만 함수의 인자들을 왼쪽부터 넣어도 문제가 없다.
오버로딩과 디폴트 인자의 충돌
void Ambiguous(int a, int b = 100);
void Ambiguous(int a);
void Ambiguous(10);
#동적 메모리 할당
컴파일 타임에는 크기를 알 수 없으며, 런 타임에 할당할 메모리의 크기가 결정되어 할당하는 방식
할당과 해제의 시점이 자유롭다.
함수 내에서 할당한 경우, 함수가 종료되더라도 Heap 영역에 남아있다.
Data 영역 - 전역 변수, Static 변수가 할당된다. 프로그램 시작시 할당, 프로그램 종료시 해제.
BBS 영역 - Data 영역에 포함된 영역. 초기화하지 않은 전역 변수가 할당된다.
Heap 영역 - 동적 할당에 사용되는 메모리
Stack 영역 - 지역변수가 할당된다. 함수 시작시 할당, 함수 종료시 해제.
main() 함수가 아닌 다른 함수에서 동적메모리를 할당하고 해제하지 않은 경우에는 반드시 그 포인터 변수를 main() 함수로 넘겨주어야 메모리 해제가 가능하다??
test99.cpp
#namespace
하나의 프로그램에 같은 이름의 변수, 함수, 클래스 등이 있으면 안된다.
이러한 것을 막기 위해 namespace를 사용한다.
main() 함수 위에 선언되어 있어야 한다.
정의
namespace NAME
{
변수, 함수, 클래스 정의
...
}
namespace를 정의한 후 그 안에 포함된 것을 사용하기 위해서는
NAME::변수, NAME::함수, NAME::클래스 등과 같이 사용한다.
1) 개별적으로 줄여서 사용하는 방법
using NAME::myfunc;
2) 네임스페이스 자체를 기본으로 설정
using namespace NAME;
#include <iostream>
using namespace std;
namespace A
{
void showTest()
{
cout << "namespace A test" << endl;
}
}
namespace B
{
void showTest()
{
cout << "namespace B test" << endl;
}
}
using B::showTest;
int main()
{
A::showTest();
showTest();
return 0;
}
Result--------------------------------------------------------------------------------------------------------------
namespace A test
namespace B test
Result--------------------------------------------------------------------------------------------------------------
|
레퍼런스
변수의 별명, 변수처럼 사용
포인터는 메모리가 할당되나 레퍼런스는 메모리가 할당되지 않고 해당변수의 별명으로만 추가될 뿐이다.
반드시 초기화해야 하며, 초기화 시에 상수를 대입할 수 없다.
한 번 초기화하면 초기화 시에 대입했던 변수 이외의 변수의 별명으로 바뀌지 않는다.
