C++第三天学习

回顾：

类和对象

class 类名

{

public:

private: 在类的类部可以访问，在类的外部不能直接访问。

protected: 在类的类部可以访问，在类的外部不能直接访问，其子类可以访问。

};

class student

{

构造函数

析构函数

};

------------------------------------------

1.初始化列表

类名(参数表):要初始化的成员变量(参数),成员变量2(参数)...

{

}

2.this指针

在类成员函数(不包括静态成员函数)中，都隐藏着一个this指针（自引用指针）

this指针：谁调用 就指向谁。

3.静态成员

为了实现一个类的多个对象之间的数据共享，C++提出了静态成员的概念。

在一个类中，如果将一个成员说明为static,这种成员称为静态成员

静态成员分为静态成员变量和静态成员函数

静态成员它不属于某个具体的对象，而是属于某种类型

调用静态成员的方法：

类名::要访问的静态成员

静态成员函数和非静态成员函数的区别：

1.静态成员函数主要用来访问静态成员变量，非静态的成员函数可以访问静态成员变量

2.静态成员函数中，是没有this指针的

4.复制/拷贝 构造函数

格式：

类名(const 类名&);

1.当在类中没有显式声明拷贝构造函数时，系统自动创建一个拷贝构造函数。

2.用一个存在的对象构建一个新对象时，会自动调用拷贝构造函数

Test t2(t1);

Test t2 = t1;

3.当函数参数为类类型时，传弟对象时，也会调用拷贝构造函数

4.系统提供的拷贝构造函数，称为浅拷贝。一旦类的成员变量中有动态内存分配，那么要使用深拷贝。

int a = 10;

int b = a;

#include<iostream>
using namespace std;

class Test
{
public:
Test(int a,int b):a(a)
{

this->b = b;
}
void show()
{
cout << this << endl;
cout << this->a << endl;
cout << this->b << endl;
}
private:
const int a;
int b;
};

int main()
{
Test t(100,200);
Test t1(10,20);
cout << "&t=" << &t << endl;
t.show();
cout << "------------" << endl;
cout << "&t1=" << &t1 << endl;
t1.show();

cout << "sizeof(Test) = " << sizeof(t) << endl;
return 0;
}

#include<iostream>
using namespace std;
class student
{
public:
student()
{
num = 1;
name = "zhangfei";
count++;
}
void show()
{
cout << "我叫" << name << ",我的学号是 " << num << endl;
}

static int getCount()
{
// cout << this << endl;//error
return count;
}

/*
void setCount(int c)
{
if(c < 0)return;
count = c;
}
*/
private:
int num;
string name;
static int count;

};
int student::count = 0;

int main()
{
cout << student::getCount() << endl;
student t1,t2;
// t1.show();
cout << student::getCount() << endl;//

};

#include<iostream>
using namespace std;

class TestCopy
{
public:
TestCopy()
{
a = 0;
b = 0;
cout << "TestCopy()" << endl;
}
/*
TestCopy(const TestCopy& tc)
{
this->a = tc.a;
this->b = tc.b;
cout << "TestCopy(const TestCopy)" << endl;
}
*/
void show()
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}
private:
int a;
int b;

};

void func(TestCopy& ft)
{
ft.show();
}

int main()
{
TestCopy t;
TestCopy t1(t);
TestCopy t2 = t1;
TestCopy t3;
t3 = t1;
t.show();
t1.show();

cout << "----------------" << endl;
func(t);
return 0;
}

#include<iostream>
using namespace std;

class Test
{
public:
Test()
{
p = new int(100);
}

Test(const Test& rt)
{
//0.
if(this == &rt)
return;
cout << &rt << endl;
cout << this << endl;
//1.开辟新空间
p = new int;
//2.拷贝内存空间中的值
*p = *(rt.p);
cout << "拷贝构造函数" << endl;
}

void show()
{
cout << *p << endl;
}

~Test()
{
delete p;
}
private:
int *p;

};

int main()
{
Test t;
Test t1(t);
t.show();
t1.show();
cout << "----------------" << endl;

Test t2(t);//??
t2.show();

return 0;
}