day6.c++语法

day 6.
类的权限
class mydata
{
public:
void get(int x)
{
i=x;
cout<<i<<endl;
}
private:int i;//默认私有
} ;
int main()
{

mydata d1;
d1.i=1;//这里是禁止访问的，因为i是私有成员
//类的私有成员只能被类内部成员访问或者友元函数、友元类
//如果想要访问可以设置公共接口间接调用；get函数；在类里面无视类作用域，即i在后面但get依然能访问；

return 0;
}

class haihua
{
public:
int book;
private:
int wife;
protect :
int money;//内部可以访问；外部不能访问，子类可以访问；

};
class xiaohua:public haihua
{
void hua()
{
money=90;//子类可以访问父类的protect ，因为是公有继承，全部权限照旧；
wife=1;//这是错误的，不能访问父类私有；
}
}
int main()
{
haihua h1;
h1.book=1;//这个可以
h1.wife=2;//这个是错误的，类外部访问不到私有成员

return 0;
}

总结
public:内外都可以访问
protect:内部可以，外部子类共有或者protect继承可以访问，只要权限低于当前权限都行；
private:只有内部可以访问，外部不可以访问，要访问必须设置像get的内部接口；
class 默认私有，Public\union默认公有；
//union无法继承，class和struct可以继承；


构造与析构再谈；

class myclass
{
public:
myclass()=default;//这样我们就有系统定义的默认构造可以不用传参，也能生成对象；
myclass(int x)//如果我们没有定义构造函数系统会默认为我们提供构造函数；
{
//如果我们在外部创建变量，而内部定义了有参数的构造 myclass m1；此时会提示错误，因为默认构造没了需要我们提供参数，所以我们想要默认构造和自定义构造可以用default；
}
~myclass()
{
//析构函数不能重载只有一个，而且不能传参；
}
} ;
//只有对象销毁才会调用析构函数，类指针销毁不会调用析构；
如
class myclass
{

myclass()
{
//构造函数没有返回值
}
~myclass()
{

}

};
void go()
{
myclass *p=new myclass;
}
int main()
{

go();

到这p被销毁，但是p是指针不是对象所以不能调用析构，这时候p指向的地方会造成内存泄漏；
return 0;
}

class myclass
{

public:
int i;//类内部初始化变量只有两种方式=或者花括号，不能用小括号
如int a=10;//对
int b{2};//对
int c(3);//错
}


类的嵌套
class poin
{
public:
int x;
int y;
point(int a,int b):x(a),y(b){}
};
class line
{
public:
point *p1;
point *p2;
line(int x1,int y1,int x2,int y2):p1(new point(x1,y1)),p2(new point(x2,y2)){}

};

类中类，嵌套类

class haihua
{
public:
class xiaohua
{
public:
int x;
int y;
xiaohua(int a,int b):x(a),y(b){}
};
xiaohua *px1,*px2;
haihua(int a1,int b1,int a2,int b2):px1(new xiaohua(a1,b1)),px2(new xiaohua(a2,b2))
{

}
} ;
int main()
{
haihua hai1(1,2,3,4);
xiaohua(1,2);//这里编译不通过，哪怕是Public也不能这样访问；
haihua::xiaohua x1(1,2);//这样可以，public,如果在private就不能
return 0;
}


const 与类

class myclas
{
public:
int x;
int y;
const int z;//常量必须初始化
myclass(int a,int b):z(a+b) {
z不能在这里初始化
如z=3；报错
}
void show() const //如果没const,my1调用不了；加上const只有const对象才能引用
{
cout<<x<<endl;
}
};
int main()
{
//对象，常量对象，只能调用带const的成员，无法修改，类的变量可以访问但是无法修改，只能访问类const函数
但是对于常量对象来说，构造和析构虽然不是const成员，也能访问；，不然怎么创建对象
const myclass my1;//声明一个常对象，相当于内部都是常量，不能被修改
my1.x=2;//这时候x不能被赋值
间接修改类的const成员
int *p=const_cast<int*>(&my1.z);
*p=3;//修改了；
return 0;
}
常量数据要么直接初始化，即=，要么在构造函数表初始化，不能再构造函数里初始化

构造函数和析构函数不能加const


class huahua
{
public:
int x;
int y;
int z;
huahua(int a=10,int b=20,int c=30):x(a),y(b),z(c){
}
void show()const
{
cout<<x<<y<<z<<endl;
}
void set(int a,int b,int c)
{
x=a;
y=b;
z=c;
}
};

int main()
{

const huahua hua1(1,2,3);//栈区
hua1.show();//可以调用，因为常对象可以调用类内常成员函数
hua1.set(2,3,4);//不可以，因为常对象不能调用普通成员函数；
const huahua *phua=new huahua(4,5,6);//堆区

huahua *const p=new huahua(1,2,3);
phua->show();//可以调用；
phua->set(1,2,3);可以，因为常指针而不是指针常量，只是不能改变指向

return 0;
}

拷贝构造
myclass
{
public:
int x;
int y;
myclass(const myclass &my)
{
x=my.x;
y=my.y;
}
} ;

void show(myclass my)
{

}
void showit(myclass &my)
{

}

void get()
{
myclass my1;
my1.x=10;
return my1;
}
int main()
{

myclass my1;
myclass my2(my1);//拷贝构造，值传递//系统提供的
myclass my3=my1;//也是拷贝构造；
我们从这回去类里自定义一个拷贝构造；
show(my1);函数传值有副本机制，也会调用拷贝构造；复制一份my1；
showit(my1);这时是引用不会调用拷贝构造，节省时间和空间
get();//函数返回值也有副本机制，会复制一份，所以也会调用拷贝构造
return 0;
}
深浅拷贝

class string
{
public:
char *pstr;
int length;
string(char *str)//这个是生成实体的构造函数，不是str2(str)那个拷贝构造，类的拷贝构造是默认的；
{
this->length=strlen(str)+1;//考虑结尾的\0；
this->pstr=new char[this->length]{0};
strcpy(this->pstr,str);//初始化
}
void show()
{
cout<<length<<" "<<pstr<<endl;
}
stirng (const string &mtstr)//深拷贝；
{
this->lenght=mystr.length;
this->pstr=new char[this->length]{0};
strcpy(this->pstr,mystr.pstr);//初始化
}
~string()
{
delete []pstr;
}
} ;
int main()
{

string str("gogogo");
string str2(str);//这里是浅拷贝；共指针指向同一片内存，如果str被销毁，str2里面的指针指向内容就不是原来内容了；
浅拷贝只是把变量复制一份转过来，指针也是
对于数据来说没问题，对于指针指向同一片内存会出问题
return 0;
}

引用和类//常引用等价于常对象；
class myclass
{

} ;
类的静态成员；

class myclass
{
public:
static int num;//静态成员变量不能赋初始值；

}
int myclass::num=0;//静态成员所有对象都能访问，只要在可见域内；
int main()
{


return 0;
}