c++一些入门基础，也是初学者容易卡住的地方

一：类和对象：

不说那么多官方概念，我认为类就是更高级于c语言的结构体。

因为它具有封装性，那么什么是封装？简单来说，类里不仅可以有变量，还可以有函数。



不过这个类是声明，不占空间，，像一个模型一样的东西，那么对象就是类的实例化！

我举个例子，如果会弹琴的朋友肯定知道看曲谱和真正弹奏的区别，那么类就是一个谱子，一个谱子可以弹奏多首曲子。

对象就是它的实例化，也就是弹出来这首曲子，曲子里有很多不同的音符，节奏，段落。

题外话：我副职业指弹吉他




以上是我个人的观点，觉得比较好理解，如果不对欢迎大神来更正。

刚才我说，c++更高级，他当然不是仅仅高级在类里可以写函数，还有很多东西需要慢慢学习。

.访问限定符：



那么来定义一个简单的类：

class Date
{
public:
void show()
{
cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
}

public:
int _year;
int _month;
int _day;
};

int main()
{
Date d1;//类实例化出对象
d1._year = 2017;
d1._month = 10;
d1._day = 9;
d1.show();

return 0;
}

通过sizeof(d1);得到d1的大小是12，它遵守内存对齐，那么难道成员函数不占空间吗？



注：空类的大小是1个字节，不是0，表示它存在，站位。

二：隐含的this指针：

1.每个成员函数（除了构造函数）都有一个指针形参，叫this，是隐含的。

2.在对象调用成员函数时，对象的地址作实参传递给成员函数的第一个指针形参。



三：默认成员函数：

1.构造函数：

无返回值

函数值与类名相同

对象实例化自动调用

可重载

如不定义，自动生成一个缺省的构造函数

无参，全缺省都认为是缺省构造函数，缺省的只能有一个。
class Date
{
public:
//Date()//无参
//{
//
//}

//Date(int year,int month,int day)//带参
//{
// this->_year = year;
// this->_month = month;
// this->_day = day;

// cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
//}

Date(int year = 2017,int month = 10,int day = 9)//缺省
{
this->_year = year;
this->_month = month;
this->_day = day;

cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
}

void show()
{
cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
}

private:
int _year;
int _month;
int _day;
};

int main()
{
Date d1(2017,10,1);
Date d2;

return 0;
}

d1后面得加括号，d2后面不能加，因为有可能被识别为其他函数。

2.拷贝构造函数：创建对象是用同类对象来初始化。

Date(const Date& d)
{
this->_year = d._year;
this->_month = d._month;
this->_day = d._day;
}定义了拷贝构造函数之后，

Date d1(2017,10,1);

Date d2(d2);//d2就和d1一样了。

d2的地址传给this，d1引用传递，否则会无穷递归，如图。



注意：必须用引用传参，不引用就会无穷递归，给d1加const。

如果未定义拷贝构造函数，会默认为值拷贝。（值拷贝有时候会有问题，比如有指针指向动态内存开辟的空间，如下）

3.析构函数：当一个对象生命周期结束，调用的成员函数，是清理工作。

类名前加~

无参数无返回值

一个类只有一个析构，未定义会自动生成缺省的

对象生命周期结束，自动调用。

接下来我写一个有指针指向动态内存开辟的空间。

class Seqlist
{
public:
Seqlist()
{
_a = (int*)malloc(sizeof(int)*5);
_size = 0;
_capacity = 5;
}

void PushBack(int x)
{
this->_a[(this->_size)++] = x;
}

void print()
{
for(size_t i = 0; i < this->_size; i++)
{
cout<<this->_a[i]<<endl;
}
}

Seqlist(const Seqlist& s)
{
int i = 0;
for(i = 0; i<s._size; i++)
{
this->_a[i] = s._a[i];
}
}

~Seqlist()
{
if(this->_a)
{
free(this->_a);
this->_a = NULL;
this->_size = 0;
this->_capacity = 0;
}
}

private:
int* _a;
size_t _size;
size_t _capacity;
};

int main()
{
Seqlist s1;
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);
s1.print();

Seqlist s2 = s1;
s2.print();
}

显然这是一个简单的顺序表，实现了尾插的功能。

析构函数最后free掉了_a，并且把它指向NULL，看起来都没有问题，不过如果不写拷贝构造函数，而直接使用的话，会出现问题。



4.运算符重载：为了让自定义类型可以用运算符

operator+合法的运算符构成函数名。

注：c++5个不支持重载的运算符：  .*    ::     sizeof    ?:    .

举例：operator<

class Date
{
public:
Date(int year = 2017,int month = 10,int day = 9)
{
_year = year;
_month = month;
_day = day;

cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
}

bool operator<(const Date& d)
{
if(this->_year < d._year)
{
return true;
}
else if(this->_year == d._year)
{
if(this->_month < d._month)
{
return true;
}
else if(this->_month == d._month)
{
if(this->_day < d._day)
{
return true;
}
}
}
return false;
}

private:
int _year;
int _month;
int _day;
};

void test()
{
Date d1(2017,1,25);
Date d2(2017,1,27);

cout<<(d1<d2)<<endl;

}

int main()
{
test();
return 0;
}

将它写入类内当成成员函数，不然访问不了私有成员。

d1<d2,其实就是d1.operator(&d1,d2),d1的地址传给this，d2引用传递。



赋值运算符重载：

class Date
{
public:
Date(int year = 2017,int month = 10,int day = 9)
{
_year = year;
_month = month;
_day = day;

//cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
}

Date& operator=(const Date& d)
{
if(this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}

return *this;
}

void show()
{
cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
}

private:
int _year;
int _month;
int _day;
};

void test()
{
Date d1(2017,1,25);
Date d2(2017,1,27);

d2 = d1;
d2.show();
}

int main()
{
test();
return 0;
}

注：引用返回是为了能够连续赋值，比如：d1 = d2 =d3;

if是为了避免两日期相同还赋值浪费时间。

拷贝构造和赋值运算符重载的区别：

Date d4 = d3;//拷贝构造，用同类对象来创建。

d4 = d3;//赋值运算符重载，已存在的两对象。