C++作用域运算符、重构、构造、析构_c++ { } 作用域 构造

@C++初学总结

引言

本文旨在对C++学习过程中不熟悉和c语言有区别之处记录，希望能帮助到需要之人。

1、作用域运算符（：：）

#include<iostream>
using namespace std;

float a=2;//全局变量
void main()
{
	int a=1;//局部变量
	cout<<a<<endl;
	cout<<::a;
}
1
2
3
4
5
6
7
8
9
10

运行输出：
1
2

函数重载

使用时注意以下两点：

1. 返回值不能不同：不可以定义两个具有相同名称，相同参数个数和相同参数类型，但返回值不同的函数
2. 调用形式不应混淆。

类

1. 类可以看做数据类型，对象可以看做变量。
2. 类由成员函数和数据成员组成，可以看做将好几个东西进行了封装，数据是可以调用的东西，而函数是可以使用的方法。
3. 成员函数既可以在类内定义，也可以在类外定义，类外定义时要注意加上作用域区分符。
4. 类成员根据操作权限的不同可以分为公有私有和受保护，公有的谁都可以进行操作，私有的只有自己人，自己人就是类内的人可以操作。
5. 定义类时不允许对数据初始化，初始化的工作外包给了构造函数和析构函数。
6. 个人认为把类和对象一个看作数据类型，一个看作变量这种想法来源于对象的定义操作，对象就是对类内东西操作的钥匙。

构造函数和析构函数

1. 构造函数无返回值，这一点要和成员函数相区别。
2. 即可在类内定义也可在类外定义。
3. 对象一旦声明，就一定要有一个有意义的初值（建议再理解一下声明和定义的区别，此处要熟知构造函数和析构函数的定义和声明的几种形式）。
4. 形式：带默认参数的构造函数的声明、参数化的、无参数的、深拷贝的构造函数声明。（以后补充
5. 构造函数初始化的方法。
6. 据第三点可知，每当创建一个对象时，系统自动调用析构函数。
7. 析构函数不可以重载，构造函数可以重载。

代码&杂例

1. 两例C++ operator

#include<iostream>
using namespace std;
class RMB
{
public:
 RMB(double value = 0.0);
	 operator double() 
	 {
	   return yuan + jf / 100.0;
	 }
	 void display() 
	 {
	   cout << (yuan + jf / 100.0) << endl; 
	   }
protected:
	 unsigned int yuan;
	 unsigned int jf;
};
RMB::RMB(double value)
	{
	 yuan = value; jf = (value - yuan) * 100 + 0.5;
	}

void main()

{
 RMB d1(2.0), d2(1.5), d3;
 d3 = RMB((double)d1 + (double)d2);
 d3.display();
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include<iostream>
#include<string>
using namespace std;

class MyStr
{
private:
    char *name;
    int id;
public:
    MyStr() {}
    MyStr(int _id, char *_name)   //constructor
    {
        cout << "constructor" << endl;
        id = _id;
        name = new char[strlen(_name) + 1];
        strcpy_s(name, strlen(_name) + 1, _name);
    }
    MyStr(const MyStr& str)
    {
        cout << "copy constructor" << endl;
        id = str.id;
        if (name != NULL)
            delete[] name;
        name = new char[strlen(str.name) + 1];
        strcpy_s(name, strlen(str.name) + 1, str.name);
    }
    MyStr& operator =(const MyStr& str)//赋值运算符
    {
        cout << "operator =" << endl;
        if (this != &str)
        {
            if (name != NULL)
                delete[] name;
            this->id = str.id;
            int len = strlen(str.name);
            name = new char[len + 1];
            strcpy_s(name, strlen(str.name) + 1, str.name);
        }
        return *this;
    }
    ~MyStr()
    {
        delete[] name;
    }
};

int main()
{
    MyStr str1(1, "hhxx");
    cout << "====================" << endl;
    MyStr str2;
    str2 = str1;
    cout << "====================" << endl;
    MyStr str3 = str2;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

2. 模板快速排序
   （1）两个参数

#include<iostream>
using namespace std;
void quickSort(int a[],int);

int main()
{
   int n;
   int array[20],k;

   cout<<"请输入需排序的数组的个数：\n";
   cin>>n;

   cout<<"请输入数组元素：\n";//<<endl;
   for(k=0;k<n;k++)
   	cin>>array[k];

   quickSort(array,n-1);

   cout<<"输出排序结果："<<endl;
   for(k=0;k<n;k++)
   	cout<<array[k]<<",";

   system("pause");
   return 0;
}

void quickSort(int s[], int r)
{
   int l=0;
   if (l< r)
   {    
   	int i = l, j = r, x = s[l];
   	while (i < j)
   	{
   		while(i < j && s[j]>= x) // 从右向左找第一个小于x的数
   			j--; 
   		if(i < j)
   			s[i++] = s[j];
   		while(i < j && s[i]< x) // 从左向右找第一个大于等于x的数
   			i++; 
   		if(i < j)
   			s[j--] = s[i];
   	}
   	s[i] = x;
   	quickSort(s, i - 1); // 递归调用
   	quickSort(s+i + 1, r-i-1);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

（2）三个参数：

#include <iostream>
using namespace std;
template<class T>

void quick_sort(T *a, int left,int right) //left和right为索引值
{
    int temp; //存储每次选定的基准数（从最左侧选基准数）
    int t;
	int initial=0;

    //***必须有这一部分
    if (left<right)  //因为在递归过程中有减1加1的情况，当其越界时，直接return,不返回任何值，即结束当前程序块
	{
	int end=right;
    temp=a[left];
    while(left<right)  //此时左右index在移动中，若left==right,则跳出循环，将基数归位
    {
        while(a[right]>=temp && left<right)  //直到找到小于基准数的值为准
            right--;
            
        while(a[left]<=temp && left<right)
            left++;
        
        //进入此部分，表明a[left]>temp而且a[right]<temp,可以进行交换
        if(left<right)  //交换左右两侧值，当left=right时，跳出外层while循环
        {
            t=a[right];
            a[right]=a[left];
            a[left]=t;
        }  
        
    }
    a[initial]=a[left];
    a[left]=temp;        //基数归位
    //递归处理归位后的基准数的左右两侧
    quick_sort(a,initial,left-1);  //此时left=right
    quick_sort(a,left+1,end);
	}
}

int main()
{
    int a[20];
    int n;

    cout<<"请输入需排序的数组的个数：\n";
    cin>>n;

    cout<<"请输入数组元素：\n";
    for (int i=0;i<n;i++)
        cin>>a[i];

    quick_sort(a,0,n-1);
 
    cout<<"排序结果：\n";
    for (int j=0;j<n;j++)
        cout<<a[j]<<" ";
    cout<<endl;  

    system("pause");
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63