文章目录
一、函数重载
在程序编译时分为四步:预编译 编译 汇编 链接
而C++的函数重载与C的区别就在于链接
生成符号表时
C : 0x000000 :
Add C语言中, .o文件符号表中地址对应的函数名为 自己创建的函数名,所以不能创建同名函数
C++: 0x000000 : _Z3Adddd 和 _Z3Addii
_Z为标志符,3为函数字符数,Add为函数名,ii为两个参数类型
由以上分析,我们可以知道函数重载的实现的重点为参数
数量or顺序or类型
不同时就能构成重载
注意,如果构建两个函数名相同的函数,若只有返回值类型的不同无法构成重载
因为其与参数无任何关系
二、缺省函数
int Func1(int a = 10, int b = 20,int c = 30)
{
return a + b;
}
int Func2(int a , int b = 20, int c = 30)
{
return a + b;
}
int main()
{
Func1();
Func1(3); //加入不完整的参数默认为从左到右,此时函数内a==3,b==20,c==30;
Func1(3, 4); //此时函数内a==3,b==4,c==30
Func1(3, 4, 5); //此时函数内a==3,b==4,c==5
return 0;
}
缺省函数有以下注意要点
1.填补缺省参数时,填补只能
从右向左
并且连续
才行
2.如果构建两个函数名称相同,参数相同,唯有参数的缺省值不同,此时并不构成重载
,反而还会报错
三、引用 &
1.引用的基本定义
引用必须在定义时就进行初始化
int& e; //这样一写九成要爆炸
关于const修饰的引用(权限的扩大和缩小)
const int f = 4; //f创建时的权限为只读
int& g = f; //此时f的引用g,可读可写,权限被放大,直接爆炸
const int f = 4;
const int& h = f; //此时权限没有放大,可行
在引用前一定要注意要引用的对象权限,只能缩小和不变,不能扩大权限
临时变量具有常性
,隐式类型转换
int k = 6;
double l = k; //可行
float& m = k; //报错
double& n = k;//报错
//此时为什么两者都不行呢?
const float& o = k; //可行
const double& p = k; //可行
//加上const不让权限放大即可
int q = 10;
const int& r = q;
q = 20; //无措且成功修改
cout << r << endl; //r变为20
r = 30; //报错
隐式类型转换发生在上述 double l = k; 时(隐式类型转换)
赋值前会先创建一个临时的double变量,k先将值赋值给这个临时的double变量,再将临时变量赋值给l
引用时报错的原因是(临时变量具有常性)
因为临时创建的临时变量具有 常性(即只读性),即访问权限放大了
2.引用作为函数参数和返回类型(浅提static,函数返回值的过程)
int& Count1()
{
static int n = 0; //static 在程序运行后只执行一次,因此程序只执行一次 static int n = 0;
n++;
return n; //返回时,引用一个临时名称代表n (int& tmp = n;)
}
int Count2()
{
static int n = 0;
n++;
return n; //在返回时,n将值赋给一个临时变量 (int tmp = n;)
}
int main()
{
int& ret1 = Count1();
const int& ret2 = Count2(); //返回的临时变量具有常性,因此加上 const 才可以通过编译
return 0;
}
关于引用作为函数返回值有最大的优点就是提升效率
由于不需要再创建额外变量,只要引用作为返回类型或者参数,提高程序运行的效率
引用中的不慎会导致的错误
int& Add(int a, int b)
{
int c = a + b;
//解决方式
//static int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
cout << ret << endl;
cout << "Add(1,2) is : " << ret << endl;
return 0;
}
为什么前面一有其他函数就会使得值变化呢?
问题就在Add函数在栈区每调用完这个栈就会销毁(下次使用这块栈区可能会直接覆盖),但是c的值还在
当有函数在此栈区运行时会使得c的别名变为随机值
所以要static修饰将其转移至静态区即可解决
引用和指针的区别
1.引用在初始化时引用一个实体后就不能再引用其他实体,而指针在没有const修饰时可以指向任何一个实体
2.没有空引用,但有空指针(NULL)
3.有多级指针,没有多级引用
4.访问实体时,指针需要解引用,引用编译器自己处理
5.引用相对于指针更安全
6.实际上在转换为汇编中指针和引用没有过大区别,效率几乎一样
四、内联函数
inline
inline void Swap(int& a, int& b)
{
int tmp = a;
a = b;
b = tmp;
}
int main()
{
auto a = 3, b = 4;
Swap(a, b);
Swap(a, b);
Swap(a, b);
Swap(a, b);
Swap(a, b);
return 0;
}
内联函数的主要作用是代替宏
汇编中直接将 main中的 call _Z4swapii 取代为swap函数内的算法
但是内联函数有以下要点
1.频繁调用Swap是有消耗的
2.inline只是对编译器进行建议,如果函数内行数过多(多于20行左右),那么内联函数就不会使用
五、类和对象
1.类的大小如何计算?
class Stack1//类中有成员函数和成员变量
{
public:
void Push(int x);
void Pop();
bool Empty();
private:
int* _a;
int _size;
int _capacity;
};
class Stack2 //类中只有成员函数
{
public:
void Push(int x);
void Pop();
bool Empty();
};
class Stack3 //类中只有成员变量
{
int* _a;
int _size;
int _capacity;
};
class Stack4 //类中什么也没有--空类
{};
int main()
{
cout << sizeof(Stack1) << endl; //16
cout << sizeof(Stack2) << endl; //1
cout << sizeof(Stack3) << endl; //16
cout << sizeof(Stack4) << endl; //1
return 0;
}
根据输出,我们有以下问题
为什么对象中只存储成员变量,不存储成员函数?
一个类实例化出多个对象,他们的成员变量可以存储不同的值
但是他们调用的成员函数是同一个,若每个对象都存储成员函数,那么将会浪费空间
对于空类和只有成员函数的类,大小是1?
开1字节不是为了存数据,而是占位,以表示该对象存在
而且要注意
计算成员变量的和,并且要考虑对齐
const Date* p1; const修饰指针指向的对象
Date const * p2; const修饰指针指向的对象
Date* const p3; const修饰指针本身
2.初始化列表
class Date
{
public:
Date(int year = 0, int month = 1, int day = 1)
:_year(year)
,_month(month)
,_day(day)
//初始化列表
{
//函数体内赋值
/*_year = year;
_month = month;
_day = day;*/
}
private:
int _year;
int _month;
int _day;
};
那么初始化列表有什么用呢?
初始化列表的初始化是分先后的,而不是一起同时初始化的,但其初始化顺序是
定义成员变量的顺序
class A
{
public:
A(int a = 10) //是构造函数,但不是无参数默认构造函数
:_a(a)
{}
private:
int _a;
};
class B
{
public:
B(int a, int ref)
:_aobj()
,_ref(ref)
,_n(10)
{}
private:
//成员变量的声明
A _aobj; //没有默认构造函数
int& _ref; //引用
const int _n; //const
};
可以理解为初始化列表是对象的成员变量定义的地方
int& _b;
A _a;
const int _c;
//这些类型都需要初始化
//所以这些成员的初始化必须使用初始化列表
3.计算一个类产生了多少个对象(小实例)
//static成员
//设计出一个类,计算这个类总共产生了多少对象
//如果仅仅只有一个全局变量来统计,那么将没有封装性,因此我们引入static成员
class A
{
public:
A()
{
n++;
}
A(const A& a)
{
n++;
}
static int GetN() //没有this指针,函数中不能访问非静态的成员
{
return n;
}
private:
int _a;
static int n; //声明 不是属于某个对象,是属于类的所有对象,属于这个类
};
int A::n = 0; //进行定义
A& f1(A& a)
//A f1(A& a)
//A f1(A a) 这三种因为引用的原因,所进行的调用次数不一样,可以影响n,会有不一样的结果
{
return a;
}
int main()
{
A a1;
A a2;
f1(a1);
cout << a1.GetN() << endl;
A a3;
A a4;
f1(a2);
cout << a1.GetN() << endl;
return 0;
}
①static的理解
上述代码有一关键点:突破类域
有两种方式
A a1;
//突破类域的两种方式
a1.f4;
A::f4;
以下是static的函数调用理解
void f1()
{
f2(); //this->f2();
}
static void f2()
{}
void f3()
{}
static void f4() //static 成员函数内部没有this指针,因此无法调用
{
f3();
}
在C++11中也有一点关于static
private:
//非静态成员变量可以声明时给缺省值
int _year = 0;
int _month = 1;
int _day = 1;
int* p = (int*)malloc(4); //指针也可以在这里开辟空间
A aa = 10;
//static int n = 0; static类型并不行
C++11中可以在声明时给
非静态
变量缺省值
4.匿名对象
class Date
{
public:
Date()
{
cout << "Date" << endl;
}
void Print()
{
cout << "Print" << endl;
}
~Date()
{
cout << "~Date" << endl;
}
private:
int _year;
};
int main()
{
Date d1; //声明周期持续到main结束
d1.Print();
//Date(); //匿名对象 生命周期只有一行
Date().Print(); //只有这一行使用这个创建的对象,别人不需要使用,这一行开始自动调用构造,结束调用析构
return 0;
}
匿名对象的生命周期只有一行,结束调用析构函数
5.全局变量,静态成员变量,调用构造和析构的顺序
class A
{public:
A(){cout << "A" << endl;}
~A(){cout << "~A" << endl;}
};
class B
{public:
B(){cout << "B" << endl;}
~B(){cout << "~B" << endl;}
};
class C
{public:
C(){cout << "C" << endl;}
~C(){cout << "~C" << endl;}
};
class D
{public:
D(){cout << "D" << endl;}
~D(){cout << "~D" << endl;}
};
A a;
int main()
{
B b;
static D d;
C c;
// A B D C
//~C ~B ~D ~A
return 0;
}
先构造全局,静态构造无优先级,和局部对象无区别
先照常析构局部对象,再释放静态,最后释放全局
6. Cpp/C 的内存分布
int globalval = 1;
static int staticglobalval = 1;//以上两种位于数据段(静态区),main函数之前就初始化,在哪里都能用,作用域是全局的
//区别,前者所有文件可用,后者只有当前"8process.cpp"可以用
int main()
{
static int staticval = 1; //位于数据段,运行到这里再初始化,作用域在main中,只能在main中使用
int val = 1; //局部变量,位于栈内
int num[10] = { 1,2,3,4 }; //栈内
char char2[] = "abcd"; //栈内
const char* pchar3 = "abcd"; //指针位于栈内,指针指向的内容位于代码段(常量区)
int* ptr1 = (int*)malloc(sizeof(int) * 4); //指针位于栈内,指向的内容位于堆
int* ptr2 = (int*)calloc(4,sizeof(int));
int* ptr3 = (int*)realloc(ptr2,sizeof(int) * 8);
free(ptr1);
free(ptr2);
//数据段(静态区)存储全局数据,静态数据
//代码段(常量区)存储可执行代码/只读常量
return 0;
}
六、new和delete
1. malloc 、free 和 new 、delete
class A
{
public:
A()
{
cout << "A" << endl;
}
~A()
{
cout << "~A" << endl;
}
};
int main()
{
//C 函数
int* p1 = (int*)malloc(sizeof(int)); //申请一个int4个字节的空间
int* p2 = (int*)malloc(sizeof(int)*10);//为指向数组的指针开辟内存
free(p1);
free(p2);
//C++ 操作符
int* p3 = new int; //申请一个int4个字节的空间
int* p4 = new int[10]; //为指向数组的指针开辟内存
int* p5 = new int(10); //申请一个int4个字节的空间,初始化为10
delete p3;
delete[] p4;
delete p5;
//这样看来功能几乎类似,那么new和delete存在的意义是什么?
A* p6 = (A*)malloc(sizeof(A));
A* p7 = new A; //申请空间+构造函数初始化
free(p6);
delete p7; //析构函数+销毁空间
return 0;
}
对于内置类型和malloc,free作用相同
对于自定义类型就有其他作用
new申请空间后对于自定义类型还会调用构造函数初始化
delete在销毁空间前还会调用自定义类型的析构函数
2.operator new 和 operator delete
在使用方法上
A* p1 = (A*)malloc(sizeof(A));
A* p2 = (A*)operator new(sizeof(A));
operator new和malloc使用方法一样
和new的区别
class A
{
A()
{}
private:
int a;
};
int main()
{
A* p1 = (A*)malloc(sizeof(A));
A* p2 = (A*)operator new(sizeof(A)); //operator new 的用法和malloc一样
//malloc申请出错时
size_t size = 3;
void* p4 = malloc(size * 1024 * 1024 * 1024); //申请3G内存,32位平台下申请绝对失败,观察失败后运行结果
cout << p4 << endl; //输出p4地址的结果是000000,失败返回0
//operator new 申请出错时
//这部分语法暂时了解
try
{
void* p5 = operator new(size * 1024 * 1024 * 1024);
cout << p5 << endl;//失败抛异常
operator delete(p5); //operator delete 和 free 没有区别,只是为了对应operator new
}
catch(exception& e)
{
cout << e.what() << endl; //输出bad allocation
}
return 0;
}
在观察operator new 和 operator delete内部,发现内部是用malloc和free实现的,在operator new内部多了一个申请出错输出bad allocation
总结
malloc
operator new -> malloc + 失败抛异常
new ->operator new + 构造函数
free
operator delete -> 和free没有区别
delete -> free + 析构函数
3.定位new和delete
int main()
{
List* p1 = new List;
delete p1;
//模拟上面的行为,即,创建对象后调用构造,销毁对象后调用析构
//显式调用构造函数和析构函数
List* p2 = (List*)malloc(sizeof(List));
new(p2)List(1);//调用构造函数,new(空间指针)类型(参数)
p2->~List(); //调用析构函数
operator delete(p2);
return 0;
}
调用构造函数为 new(空间指针)类型(参数)
调用析构函数为 空间指针->析构函数名()
4.总结new,malloc…
使用效果上: new会调用构造函数,失败了抛异常,malloc失败返回0
概念性质上: new是一个操作符,malloc是一个函数
使用方法上: new后面跟申请对象的类型,返回的是类型的指针;malloc参数传字节数,返回值为void*