C++概述的那些事

🌞欢迎来到数据结构的世界 
🌈博客主页：卿云阁

💌欢迎关注🎉点赞👍收藏⭐️留言📝

🌟本文由卿云阁原创！

🌠本阶段属于练气阶段，希望各位仙友顺利完成突破

📆首发时间：🌹2021年2月18日🌹

✉️希望可以和大家一起完成进阶之路！

🙏作者水平很有限，如果发现错误，请留言轰炸哦！万分感谢！

---

目录

0️⃣C++特点及构成及C++输入输出

1️⃣函数原型

2️⃣ 内联函数

3️⃣默参函数与重载函数

4️⃣ 运算符new和delete

5️⃣ 引用

 0️⃣✨✨✨C++特点及构成及C++输入输出✨✨✨ 

❖C++程序的结构

类的定义部分由成员变量及成员函数组成

类的使用部分由主函数main及其中的对象组成

❖C++注释 C++注释的两种方式：

① //… :注释方式适合注释内容不超过一行的注释

② /* … */ :注释方式适合注释内容多行的注释 

❖C++输入输出

cin>>变量;

cout<<变量;

换行控制符endl，其作用与’ \n’相同。

❖const修饰符

 C宏定义define

#define 标识符 字符串

“#”为预处理命令 “标识符”为所定义的宏名

“字符串”可以是常数、表达式、格式串等

如：#define PI 3.14159

① 标识符PI没有定义其数据类型

② 预编译时进行标识符置换 把程序中出现的标识符PI全部置换为3.14159 在预编译后，程序中不再有PI这个标识符。

#include<iostream> 
using namespace std; 
int main()
{
int a=1；
#define T1 a+a
#define T2 T1-T1
cout<<＂T2 is＂<<T2<<endl；
return 0；
}

实际输出结果是： T2 is 2

❖C++的const修饰符

在C中用define定义常量。

如#define PI 3.14159 在C++用const修饰符来定义常量

如：const float PI=3.14159;

① 常量const修饰符是有类型的。它占用存储单元，有地址， 可以用指针指向这个值，但不能修改它

② const的作用与#define相似，但它消除了#define的不安全 性。const定义的常量可以有自己的数据类型,这样C++的编 译程序可以进行更加严格的类型检查,具有良好的编译时的检测性。

#include<iostream> 
using namespace std; 
int main()
{ 
int a=1；
const int T1=a+a；
const int T2=T1-T1；
cout <<＂T2 is＂<<T2<<endl；
return 0；
}

 

❖函数形参的const说明

函数的形参也可以用const说明,用于保证形参在该函数内部不被改动 ，即在函数中对这些参数只许读，而不许写。

例如, 希望通过函数i_Max求出整型数组a[200]中的最大值。

函数原型： int i_Max(const int *ptr);

调用时格式: i_Max(a);

调用后，能够找出数组中的最大元素,但对200个数组元素的操作只许读,而不许写。 这样做的目的是确保原数组中的数据不被破坏 。

❖const修饰符与指针的组合

const可以与指针一起使用,

组合情况可归纳为三种：

. 指向常量的指针变量

. 常指针

. 指向常量的常指针

1）指向常量的指针变量

例如： const char * name= “chen”;

含义：声明一个名name的指针变量，初始化指针变量name为指向常量 字符串“chen”。

判断： name[3]= ‘a’;         × 不允许改变指针所指地址中常量“chen”。

            name= “zhang”;   √ 可以改变指针变量name的值

2）常指针 常指针是指：把指针所指的地址声明为常量，而不是它指向的对象声 明为常量。 例如： char* const name= “chen”;

含义：声明一个名为name的指针变量，该指针是指向字符型数据的常 指针，

用“chen”的地址初始化该常指针。

判断： name[3]= ‘a’; √ 可以改变指针所指的数据，name没改变。

           name= “zhang”;× 不可以修改常指针name的值

3）指向常量的常指针 这个指针本身不能改变,它所指向的地址中数据也不能改变。

例如： const char* const name=“chen”；

含义：声明了一个名为name的指针变量，它是一个指向字符型常量的 常指针，用“chen”的地址初始化该指针。

判断： name[3]= ‘a’;× 不允常量值许“chen”。

            name= “zhang”; × 不可以修改常指针name的值。 

---

1️⃣✨✨✨函数原型✨✨✨

❖函数原型

C++要求为每一个函数建立函数原型,以说明函数的：

① 函数返回值数据类型

② 函数名称

③ 参数数据类型与个数

语法形式: 返回值数据类型 函数名(参数列表);

让C++编译程序进行数据类型检查,以维护程序的正确性。

① 形参与实参的数据类型匹配检查

② 返回值类型与原型相符性检查

❖函数原型的调用形式

1）函数原型声明    函数调用    函数定义

#include<iostream> 
using namespace std; 
void test(char *s)；
void main()
{ test(＂Hello，world！＂)；
}
void test(char *s) 
{ cout<<s；
return; }

2）同时函数原型声明与定义 函数调用

#include<iostream> 
using namespace std; 
void test(char *s)
{ cout<<s；
return; }
void main()
{ test(＂Hello，world！＂)；
}

---

2️⃣✨✨✨ 内联函数✨✨✨

❖普通函数的调用过程

#include<iostream>
using namespace std; 
float getArea(float radius) 
{ float a=3.1416* radius * radius;
return a;}
int main()
{ float area , r=4;
area = getArea(r);//调用普通函数
cout<<"area="<<area<<endl;
return 0; }

转去调用函数float getArea(float radius)， 实参r=4赋值给形参radius

return函数运算结果a

返回值a拷贝在寄存器中一个临时变量中；函数运行结束

临时变量赋值给area

❖内联函数

inline 返回值数据类型 函数名(参数列表) { /*内联函数实现 */ }

运行方式：当程序中出现对内联函数的调用时,C++编译器使用内 联函数体中代码替代普通函数的调用。

#include<iostream>
using namespace std; 
inline float getArea(float radius) 
{ float a=3.1416* radius * radius;
return a;}
int main()
{float area , r=4;
area = getArea(r);//调用内联函数
cout<<"area="<<area<<endl;
return 0; }

用代码 { float a=3.1416*r*r; return a;} 替换getArea(r)。

计算结果a直接赋值给area。 内联函数减少普通函数调用的时空开销。

通常只有规模很小（一般为1～5条语句），且使用频繁的函 数才定义为内联函数, 这样可大大提高运行速度,在内联函数体内一般不能含有复杂的控制语句,如for语句和 switch语句等。

C++的内联函数具有与C中的宏定义 #define相同的作用和相似的机理，但 消除了#define的不安全因素

C语言中： #define doub(x) x*2 则语句doub(1+2)被解释成： 1+2*2 结果为5,造成误解。

C++语言中： inline int doub(int x) { return x*2; } 则语句doub(1+2)被解释成： (1+2)*2 结果为6

---

3️⃣✨✨✨默参函数与重载函数✨✨✨

❖带有默认参数的函数

#include<iostream>
using namespace std; 
int special(int x=5,float y=5.3)
{
int X=x;
float Y=y;
}

int main()
{
special( );
special(25);
special(100,79.8);

return 0; }

 

 

❖函数的重载

在传统的C语言中，在同一作用域中，不允许出现同名的函数。

例如:求整数和双精度数的平方。 在传统的C语言中，

例如:
 

Isquare(int i); //求整数的平方数

Dsquare(double d)；//求双精度数的平方数

在C++中，允许两个或者两个以上的函数共用一个函数名。

例如:

square(int i); //求整数的平方数

square(double d)； //求双精度数的平方 

当两个或者两个以上的函数共用一个函数名时，称为函数重载。

被重载的函数称为重载函数。

重载函数的区分：

① 重载函数应在参数个数或参数类型上有所不同，或二者兼之。

② 若两个函数的参数个数和类型都相同,仅仅是函数返回值类型 不同,则不是函数重载。

int mul(int x,int y); double mul(int x,int y); 编译器无法区分这两个函数

---

4️⃣ ✨✨✨运算符new和delete✨✨✨  

❖运算符new和delete 运算符new用于内存分配的最基本形式为:

指针变量名 = new 数据类型;

运算符new就从存储区中为程序分配一块与数据类型字节数相适 应的内存空间,并将该块内存的首地址存于指针变量中。

运算符delete用于释放new分配的存储空间的使用形式一般为：

delete 指针变量名；

其中，指针变量名表示new分配数据的内存首地址

#include<iostream> 
using namespace std; 
int main()
{
int *p; 
p=new int;
*p=10;
cout<<*p;
delete p;
return 0;
}

#include<iostream> 
using namespace std; 
int main(){
int* s;
s=new int[5];
if (!s)
{ cout <<"allocation failure\n";
return 1;}
for (int i=0;i<5;i++) s[i]=100 + 2*i;
for (int j=0;j<5;j++) cout<<s[j]<<" ";
delete []s;
return 0; 
}

 

---

5️⃣ ✨✨✨引用✨✨✨   

建立引用的作用是为变量另起一个名字,变量的引用通常被认为 是变量的别名。 & 表示引用运算符。

数据类型 & 引用名 = 已定义的变量名;

int i=5； 
int &j = i；

声明了一个整数类型的引用整型变量j，用整型变量i对它进行 初始化。这时j就可看做是变量i的引用,即是变量i的别名

可以建立指针变量的引用。
 

int i=5; //定义整型变量i，初值为5

int *p=&i; //定义指针变量p，指向i

int* &pt=p; //pt是对指针变量p引用，*pt值就是*p的值5

引用与函数 

传值调用

#include<iostream>
using namespace std;
void swap(int m,int n){
int temp;
temp=m;
m=n;
n=temp;
} 
int main() 
{ int a=5,b=10;
cout<<"a="<<a<<"b="<<b<<endl;
swap(a,b);
cout<<"a="<<a<<"b="<<b<<endl;
return 0;}

 传址调用--指针变量作为参数

#include<iostream>
using namespace std;
void swap(int* m,int* n){
int temp;
temp=*m; 
*m=*n; 
*n=temp;
} 

int main() 
{ int a=5,b=10;
cout<<"a="<<a<<"b="<<b<<endl;
swap(&a,&b);
cout<<"a="<<a<<"b="<<b<<endl;
return 0;}

  传址调用--指针变量作为参数

void swap(int& m,int& n){
int temp；
temp=m； m=n； n=temp；
} 
int main() 
{ int a=5,b=10；
cout<<"a="<<a<<"b="<<b<<endl；
swap(a,b)；
cout<<"a="<<a<<"b="<<b<<endl；
return 0；}

❖一般形式的函数返回值

double getSum(double m, double n){
double tempSum；
tempSum=m+n;
return tempSum;
} 
int main(){
double a=5.4,b=10.2,sum；
sum=getSum(a,b)；
cout<<"a+b="<<sum<<endl；
return 0；}

❖引用形式的函数返回值

​
int max;
int & getMax(int x,int y){
if(x>y) max=x; else max=y;
return max; } 
int main(){
int a,b,c；cin>>a>>b；
c=getMax(a,b);cout<<c<<endl；
getMax(a,b)=6;
cout<<max<<endl;
return 0；}


​