new ์ฐ์ฐ์๋ฅผ ์ด์ฉํ ์ด๊ธฐํ
๋ณ์๋ฅผ ์์ฑํ๊ณ ์ด๊ธฐํํ๊ธฐ ์ํ ์ ์ฅ๊ณต๊ฐ์ ์ํ๋ค๋ฉด, ๊ดํธ๋ฅผ ์ด์ฉํด ์ด๊ธฐ ๊ฐ ์ค์ ๊ฐ๋ฅ
int *pi = new int(6);
double *pd = new double(99.99);
์์ฐจ์ ์ธ ๊ตฌ์กฐ์ฒด๋ ๋ณ์์ ์ด๊ธฐํ๋ c++11์์๋ง ๊ฐ๋ฅ
๋ํ ์ค๊ดํธ๋ฅผ ์ด์ฉํ ๋ฆฌ์คํธ ์ด๊ธฐํ๋ฅผ ์ฌ์ฉํด์ผ ํจ
struct where{double x;double y;double z;};
where *one = new where{2.5,5.7,7.2};
int *ar = new int[4]{2,4,6,7};
c++11์์๋ ๋จ์ผ ๊ฐ์ ๊ฐ์ง๋ ๋ณ์์ ๋ํด์๋ ์ค๊ดํธ๋ฅผ ์ด์ฉํ ์ด๊ธฐํ ๊ฐ๋ฅ
int *pin = new int{6};
double *pdo = new double{99.99};
์์น ์ง์ new ์ฐ์ฐ์
new ์ฐ์ฐ์๋, ์ฌ์ฉํ ์์น๋ฅผ ์ฌ์ฉ์๊ฐ ์ง์ ํ ์ ์๋ ์์น ์ง์ new๋ผ๋ ๋ณํ์ด ์๋ค.
๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ์ ์ฐจ๋ฅผ ์ค์ ํ๊ฑฐ๋ ํน์ ์ฃผ์๋ฅผ ํตํด ์ ๊ทผํ๋ ํ๋์จ์ด๋ฅผ ๋ค๋ฃจ๊ณ , ํน์ ๋ฉ๋ชจ๋ฆฌ ์์น์ ์๋ ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ ๋ฐ ์ฌ์ฉ
์์น ์ง์ new๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด, ๋จผ์ new ํค๋ ํ์ผ์ ํฌํจ์์ผ์ผ ํจ
๊ทธ ํ ์ํ๋ ์ฃผ์๋ฅผ ์ ๊ณตํ๋ ๋งค๊ฐ๋ณ์์ ํจ๊ป new๋ฅผ ์ฌ์ฉ
#include<new>
struct chaff
{
char dross[20];
int slag;
};
char buffer1[50];
char buffer2[50];
int main()
{
chaff *p1,*p2;
int *p3,*p4;
p1=new chaff;
p3=new int[20];
p2=new(buffer1) chaff;
p4=new(buffer2) int[20];
}
์ด๋ฆ ๊ณต๊ฐ
๊ตฌ์ c++ ์ด๋ฆ ๊ณต๊ฐ
์ ์ธ ์์ญ : ์ ์ธ์ ํ ์ ์๋ ์์ญ
ex) ์ ์ญ ๋ณ์๋ ๋ชจ๋ ํจ์์ ๋ฐ๊นฅ์์ ์ ์ธ ๊ฐ๋ฅ
์ด ๋ณ์์ ์ ์ธ ์์ญ์ ์ ์ธ๋ ํ์ผ์ด๋ค.
์ด๋ค ๋ณ์๋ฅผ ํจ์ ์์ ์ ์ธํ๋ฉด, ๊ทธ ๋ณ์์ ์ ์ธ ์์ญ์ ์ ์ธ๋ ๋ธ๋ก์ด๋ค.
์ ์ฌ ์ฌ์ฉ ๋ฒ์: ์ด๋ค ๋ณ์์ ์ ์ฌ ์ฌ์ฉ ๋ฒ์๋, ๋ณ์๋ฅผ ์ ์ธํ ์ง์ ๋ถํฐ ์ ์ธ ์์ญ์ ๋๊น์ง ์ด๋ค.
์๋ก์ด ์ด๋ฆ ๊ณต๊ฐ ๊ธฐ๋ฅ
์๋ก์ด ์ข ๋ฅ์ ์ ์ธ ์์ญ์ ์ ์ํจ์ผ๋ก์จ ์ด๋ฆ์ด ๋ช ๋ช ๋ ์ด๋ฆ ๊ณต๊ฐ์ ๋ง๋ค ์ ์๋ค.
ex)
namespace Jack{
double pail;
void fetch();
int pal;
struct well{...};
}
namespace Jill{
double bucket(double n){...}
double fetch;
int pal;
struct Hill{...}
}
์ด๋ฆ ๊ณต๊ฐ์ ์ ์ญ ์์น ๋๋ ๋ค๋ฅธ ์ด๋ฆ ๊ณต๊ฐ ์์๋ ๋์ผ ์ ์์ง๋ง ๋ธ๋ก ์์๋ ๋์ผ ์ ์๋ค. (๊ธฐ๋ณธ์ ์ผ๋ก ์ธ๋ถ ๋งํฌ๋ฅผ ๊ฐ์ง)
์ฌ์ฉ์๊ฐ ์ ์ํ๋ ์ด๋ฆ ๊ณต๊ฐ ์ธ์, ์ ์ญ ์ด๋ฆ ๊ณต๊ฐ์ด๋ผ๋ ๋ ํ๋์ ์ด๋ฆ ๊ณต๊ฐ์ด ์๋ค.
์ด๋ค ํ๋์ ์ด๋ฆ ๊ณต๊ฐ์ ์ํ ์ด๋ฆ์ ๋ค๋ฅธ ์ด๋ฆ ๊ณต๊ฐ์ ์ํ ์ด๋ฆ๊ณผ ์ถฉ๋ํ์ง ์๋๋ค.
๊ธฐ์กด์ ์ด๋ฆ ๊ณต๊ฐ์ ์๋ก์ด ์ด๋ฆ ์ถ๊ฐ ๊ฐ๋ฅ
namespace Jill{
char * goose(const char *);
}
๋ง์ฐฌ๊ฐ์ง๋ก ๋ค์ Jack๋ผ๋ ์ด๋ฆ ๊ณต๊ฐ์ ์ฌ์ฉํ์ฌ ๊ทธ ํ์ผ์ ๋ค์ ๊ทธ ํจ์์ ์ฝ๋๋ฅผ ์ ๊ณต ๊ฐ๋ฅ
namespace Jack{
void fetch()
{
...
}
}
์ด๋ฆ์ด ์ ๊ทผํ๋ ๊ฐ์ฅ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ ์ฌ์ฉ ๋ฒ์ ๊ฒฐ์ ์ฐ์ฐ์ :: ์ ์ฌ์ฉํ๋ ๊ฒ
Jack::pail=12.34;
Jill::Hill male;
Jack::fetch();
using ์ ์ธ๊ณผ using ์ง์์
using ์ ์ธ์ ํ๋์ ํน๋ณํ ์๋ณ์๋ฅผ ์ฌ์ฉํ ์ ์๊ฒ ๋ง๋ค๊ณ , using ์ง์์๋ ๊ทธ ์ด๋ฆ ๊ณต๊ฐ ์ ์ฒด์ ์ ๊ทผ ๊ฐ๋ฅ.
using ์ ์ธ์ ์ ํ๋ ์ด๋ฆ ์์ ํค์๋ using์ ๋ถ์ด๋ ๊ฒ
using Jill::fetch;
์ด ์ ์ธ์ ํ ์ดํ์๋ Jill::fetch ๋์ fetch ์ฌ์ฉ ๊ฐ๋ฅ
using ์ ์ธ์ ์ธ๋ถ ์์น์ ๋์ผ๋ฉด, ๊ทธ ์ด๋ฆ์ด ์ ์ญ ์ด๋ฆ ๊ณต๊ฐ์ ์ถ๊ฐ๋จ.
using ์ ์ธ์ ํ๋์ ์ด๋ฆ์ ์ฌ์ฉํ๊ฒ ํ์ง๋ง
using ์ง์์๋ ๋ชจ๋ ์ด๋ฆ์ ์ฌ์ฉํ๊ฒ ํ๋ค.
using namespace Jack; //Jack์ ์ํ ๋ชจ๋ ์ด๋ฆ ์ฌ์ฉ
using ์ง์์์ using ์ ์ธ๊ณผ ๊ด๋ จํ์ฌ ๊ธฐ์ตํด์ผ ํ ๊ฒ์, ์ด๋ฆ ์ถฉ๋์ ๊ฐ๋ฅ์ฑ์ ์ฆ๊ฐ์ํด.
Jack::pal=3;
Jill::pal=10; //์ถฉ๋ x
using Jack::pal;
using Jill::pal;
pal=4; //์ถฉ๋ o
์ปดํ์ผ๋ฌ๋ ๋ using ์ ์ธ์ ํจ๊ป ์ฌ์ฉํ๋ ๊ฒ์ ํ๋ฝํ์ง ์์
์ด๋ฆ ๊ณต๊ฐ์ ๋ํ ๋ณด์ถฉ
์ด๋ฆ ๊ณต๊ฐ ์ ์ธ์ ์ค์ฒฉ์ํฌ ์ ์๋ค.
namespace elements
{
namespace fire
{int flame; ...}
float water;
}
์ด ๊ฒฝ์ฐ flame ๋ณ์๋ฅผ elements::fire::flame๋ก ์ฐธ์กฐํ๋ค.
using ์ง์์๋ฅผ ์ฌ์ฉํ๋ฉด ๋ด๋ถ์ ์ด๋ฆ ์ฌ์ฉ ๊ฐ๋ฅ
using namespace elements::fire;
์ด๋ฆ ๊ณต๊ฐ ์์ using ์ง์์์ using ์ ์ธ์ ์ฌ์ฉ ๊ฐ๋ฅ
namespace myth
{
using Jill::fetch;
using namespace elements;
using std::cout;
using std::cin;
}
Jill::fetch์ ์ ๊ทผํ๋ ๋ฒ
1. myth::fecth;
2. Jill::fetch;
3. using namespace myth;
cin>>fetch;
using ์ง์์๋ ๊ณผ๋์ (transitive)์ด๋ค.
A op B์ B op C๊ฐ A op C๋ฅผ ์๋ฏธํ๋ค๋ฉด op๋ฅผ ๊ณผ๋์ ์ด๋ผ ํจ
๋ฐ๋ผ์ ๋ค์๊ณผ ๊ฐ์ ๊ตฌ๋ฌธ์
using namespace myth;
๋ค์๊ณผ ๊ฐ์ ๊ฒ์ด ๋๋ค.
using namespace myth;
using namespace elements;
์ด๋ค ์ด๋ฆ ๊ณต๊ฐ์ ๋ํ ๋์ฉ ์ด๋ฆ์ ๋ง๋ค ์ ์๋ค.
namespace my_very_favorite_things {...};
mvft๋ฅผ my_very_favorite_things์ ๋์ฉ ์ด๋ฆ์ผ๋ก ๋ง๋ค ์ ์๋ค.
namespace mvft = my_very_favorite_things;
์ค์ฒฉ๋ ์ด๋ฆ ๊ณต๊ฐ์ ๊ฐ๋จํ๊ฒ ์ฌ์ฉ ๊ฐ๋ฅ
namespace MEF = myth::elements::fire;
using MEF::flame;
์ด๋ฆ์ ๋ช ๋ช ํ์ง ์์ ์ด๋ฆ ๊ณต๊ฐ
namespace
{
int ice;
int bandycoot;
}
์ด ์ฝ๋๋ ๋ง์น using ์ง์์๊ฐ ๋ค์ ์๋ ๊ฒ์ฒ๋ผ ํ๋ํจ.
๋ด๋ถ ๋งํฌ๋ฅผ ๊ฐ์ง๋ ์ ์ ๋ณ์ ๋์ ์ฌ์ฉ ๊ฐ๋ฅ