C++_note

1、类必须先声明后使用，即class 类名{ }；必须加分号，其是类声明语句的结束标志。类成员，不加访问权限关键字时，默认所有成员声明为private权限。注意与Java的区

别，Java中则是默认为protected权限。

2、在类中声明的成员函数用来对数据成员进行操作，还必须在程序中实现这些成员函数。格式为void Point：：Display（）{}。如果成员函数的定义是在类体中给出的，则

默认为内联函数；如果没有在类声明中给出成员函数的定义，仅仅是成员函数的声明，要想定义内联函数，则可以在类体外，实现这些成员函数时，在其类型前面加上inline关键字

3、在声明类时，不能在类体中给数据成员赋值；数据成员的具体值（是用来描述对象的属性的）是在产生对象时，才对它进行初始化，即对象的初始化。只有产生了一个具体的

对象，这些数据值才有意义。

4、初始化是调用类的构造函数；赋初值是有了对象后，对象调用自己的成员函数实现成员变量的赋值操作。

5、运算符的重载有两种形式：定义为类的类友元函数(有几个操作数，就有几个参数)；定义为它将要操作的类的成员函数（有n个操作数，就有n-1个参数）。前者称为友元运

算符函数，后者为成员运算符函数。当以类的类友元函数形式出现时，在类体外实现该方法时，不需要加该方法的所属类符号“：：“。运算符重载函数一般格式为，"所操作的类

的类型  operator 重载运算符号 （运算符号的操作数类型  变量）{ }”不能用友元函数重载的运算符为：= （） [ ]   ->

代码示例：

#include<iostream>
using namespace std;
class nclass{
    int a,b;
    public:
        nclass(int x=0,int y=0){
            a=x;
            b=y;
        }
        friend nclass operator-(nclass obj);
        void show();
};
nclass operator-(nclass obj){
    obj.a=-obj.a;
    obj.b=-obj.b;
    return obj;
}
void nclass::show(){
    cout<<"a="<<a<<" "<<"b="<<b<<"\n";
}
main(){
    nclass ob1(10,20),ob2;
    cout<<"没改变前ob1的成员变量值为："<<"\n";
    ob1.show();
    cout<<"改变后的ob1的成员变量值为："<<"\n";
    ob2=-ob1;
    ob1.show();//注意ob1的成员变量值没有变
    cout<<"重载运算符后ob2的成员变量值为："<<"\n";
    ob2.show();
    return 0;
}

结果为：

示例二、

#include<iostream>
using namespace std;
class coord{
    public:
        coord(int i=0,int j=0);
        void print();
        friend coord operator++(coord op);
        private:
            int x,y;
};
coord::coord(int i,int j){
    x=i;
    y=j;
}
void coord::print(){
    cout<<"x: "<<x<<" "<<"y: "<<y<<"\n";
}
coord operator++(coord op){
    ++op.x;
    ++op.y;
    return op;
}
main(){
    coord ob(10,20),oc;
    cout<<"没改变前ob的成员变量值为："<<"\n";
    ob.print();

    operator++(ob);
    cout<<"operator++(ob)后的ob成员变量值为："<<"\n";
    ob.print();

    cout<<"++ob后的ob成员变量值为："<<"\n";
    ++ob;
    ob.print();

    cout<<" oc=++ob后的ob成员变量值为："<<"\n";
    oc=++ob;
    oc.print();
    return 0;
}

结果为：

总结，此时仍然是值传递机制。所以ob的内容没有变。

示例三、成员函数为重载运算符的形式；

#include<iostream>
using namespace std;
class coord{
    int x,y;
    public :
        coord(int i=0,int j=0);
        void print();
        coord operator++();
};
coord::coord(int i,int j){
    x=i;
    y=j;
}
void coord::print(){
    cout<<"x="<<x<<",y="<<y<<endl;
}
coord coord::operator++(){
    ++x;
    ++y;
    return *this;
}
main(){
    coord ob(10,20);
    cout<<"没改变前ob的成员变量值为："<<"\n";
    ob.print();
    cout<<"++ob后ob1的成员变量值为："<<"\n";
    ++ob;
    ob.print();
    cout<<"ob.operator++()后ob1的成员变量值为："<<"\n";
    ob.operator++();
    ob.print();
    return 0;
}

结果显示为：

总结，此时是引用传递方式。

相关参考链接还有：http://www.th7.cn/Program/cp/201702/1107736.shtml

    https://wenku.baidu.com/view/1fe7215abe23482fb4da4c45.html###

6、sort的使用：

定义排序函数：


方法1：声明外部比较函数


bool Less(const Student& s1, const Student& s2){    return s1.name < s2.name; //从小到大排序}std::sort(sutVector.begin(), stuVector.end(), Less);
注意：比较函数必须写在类外部（全局区域）或声明为静态函数



当comp作为类的成员函数时，默认拥有一个this指针，这样和sort函数所需要使用的排序函数类型不一样。


否则，会出现错误
 


方法2：重载类的比较运算符


bool operator<(const Student& s1, const Student& s2){    return s1.name < s2.name; //从小到大排序}std::sort(sutVector.begin(), stuVector.end());
方法3：声明比较类




struct Less{    bool operator()(const Student& s1, const Student& s2)    {        return s1.name < s2.name; //从小到大排序    }};std::sort(sutVector.begin(), stuVector.end(), Less());



（一）为什么要用c++标准库里的排序函数Sort（）函数是c++一种排序方法之一，学会了这种方法也打消我学习c++以来使用的冒泡排序和选择排序所带来的执行效率不高的问

题！因为它使用的排序方法是类似于快排的方法，时间复杂度为n*log2(n)，执行效率较高！（二）c++标准库里的排序函数的使用方法I）Sort函数包含在头文件为

#include<algorithm>的c++标准库中，调用标准库里的排序方法可以不必知道其内部是如何实现的，只要出现我们想要的结果即可！II）Sort函数有三个参数：（1）第一个是要

排序的数组的起始地址。（2）第二个是结束的地址（最后一位要排序的地址）（3）第三个参数是排序的方法，可以是从大到小也可是从小到大，还可以不写第三个参数，此

时默认的排序方法是从小到大排序。Sort函数使用模板:Sort(start,end,,排序方法)下面就具体使用sort（）函数结合对数组里的十个数进行排序做一个说明！例一：sort函数没有

第三个参数，实现的是从小到大#include<iostream>#include<algorithm>using namespace std;int main(){ int a[10]={9,6,3,8,5,2,7,4,1,0}; for(int i=0;i<10;i++) cout<<a[i]

<<endl;sort(a,a+10); for(int i=0;i<10;i++) cout<<a[i]<<endl; return 0;}例二通过上面的例子，会产生疑问：要实现从大到小的排序肿么办？ 这就如前文所说需要在sort（）函数

里的第三个参数里做文章了，告诉程序我要从大到小排序！需要加入一个比较函数 complare(),此函数的实现过程是这样的bool complare(int a,int b){ return a>b;}这就是告诉程

序要实现从大到小的排序的方法！#include<iostream>#include<algorithm>using namespace std;bool complare(int a,int b){ return a>b;}int main(){ int a[10]=

{9,6,3,8,5,2,7,4,1,0}; for(int i=0;i<10;i++) cout<<a[i]<<endl; sort(a,a+10,complare);//在这里就不需要对complare函数传入参数了，//这是规则 for(int i=0;i<10;i++) cout<<a[i]

<<endl; return 0;}例三：通过上面例一、二的方法虽然实现了从大到小和从大到小的排序，这样做还是有点麻烦，因为还需要自己编写告诉程序进行何种排序的函数，c++标准

库强大的功能完全可以解决这种麻烦。Sortt函数的第三个参数可以用这样的语句告诉程序你所采用的排序原则less<数据类型>()//从小到大排序greater<数据类型>()//从大到小排

序结合本例子，这样的就可以完成你想要的任何一种排序原则了#include<iostream>#include<algorithm>using namespace std;int main(){ int a[10]={9,6,3,8,5,2,7,4,1,0}; for(int 

i=0;i<10;i++) cout<<a[i]<<endl;sort(a,a+10,less<int>()); for(int i=0;i<10;i++) cout<<a[i]<<endl; return 0;}#include<iostream>#include<algorithm>using namespace std;int 

main(){ int a[10]={9,6,3,8,5,2,7,4,1,0}; for(int i=0;i<10;i++) cout<<a[i]<<endl; sort(a,a+10,greater<int>()); for(int i=0;i<10;i++) cout<<a[i]<<endl; return 0;}例四：利用sort函数还

可以实现对字符的排序，排序方法大同小异，下面就把程序范例展示一下#include<iostream>#include<algorithm>using namespace std;int main(){ char a[11]="asdfghjklk"; 

for(int i=0;i<10;i++) cout<<a[i]<<endl; sort(a,a+10,greater<char>()); for(int i=0;i<10;i++) cout<<a[i]<<endl; return 0;}