1、C语言：面向过程的（函数（模块）：描述一个功能的过程）
2、C++:面向对象（OOP）
3、C++:完全兼容C语言（包含），新增对象的知识
4、共同点与不同点
不同点：
头文件：
C语言的头文件： 带.h stdio.h
C++的文件 ： 不带.h iostream
源代码的后缀：
C语言的后缀名： work.c
C++缀名： work.cpp work.C
输入输出：
C语言的输出(函数)： printf();
C++的输出(对象)： cout<<信息;
c++的输入(对象)： cin>>变量名;
endl换行
总结：>> << 只能基本类型进行操作 （*）
编译器：
c语言的编译器： gcc
C++的编译器 ： g++
共同点：
C、C++的都有一个主函数：系统来调用
int main()
{
}
程序：算法+数据
C++语言的数据：
1、基本类型： 整型，浮点型，字符型，bool类型
2、变量：此块空间的内容可改变
类型 变量名;//分配空间：以类型
初始化变量:在定义变量同时赋初值
引用：通过名字引用变量的内容
整型变量：
类型 变量名;
常量：（空间不能改）不可以改变的量
整型常量 ：
十进制199 (权10 每一位[0 9])
八进制： 0100 （权8 ，每一位[0,7]）
十六进制：0x12 (权16 每一位[0,...,9,a,b,c,d,e,f)
3、运算符：
1、插入流 <<
2、输入流 >>
4、作用域：能被引用的区间
局部变量：在函数内定义的变量
作用域：在函数内
全局变量：在函数外定义的变量
注：局部变量优先
5、引用作用域的内容：
空间名::变量名;
6、指针：就是空间在内存所在空间的地址编号
指针变量：存放指针的变量
7、取别名：给变量名取别名
规则： 类型名& 别名=变量;
int a=100;
8、重载：C++允许同名的函数，调用函数时由函数与形参共同来决定调用。
C语言规定：同一作用域下允许出现同名现象（函数名、变量）
调用函数：函数名和形参
注：1、typedef只能对类型取别名 typedef int Intgerr
2、取别名一定要指向
9、函数模板
在同族函数内，过程一致，只是数据不一致。将函数定义定义为一个通用的模型。
template<typename T> 或 template<class T>
T add(T a,T b)
{
}
取别名 int& pa = a; 将a取名为pa , pa的作用域还是a的作用域 , 地址相同 .
#include<iostream>
using namespace std;
//传递地址，
void fun(int* pa)
{
/*
a=7979;
cout<<"fun::"<<a<<endl;
*/
*pa=7979;
cout<<"fun::"<<*pa<<endl;
}
//别名为形参
void alter(int& pa)
{
pa=8989;
cout<<"alter::"<<pa<<endl;
}
int main()
{
//定义变量：
int a=200;
// fun(NULL);
// cout<<"main::"<<a<<endl;
alter(a);
cout<<"main::"<<a<<endl;
//定义（指针）变量：类型 变量名
// int a=100;
/*
int* pa=NULL;//pa没有指向
cout<<pa<<endl; //引用变量引用变量的内容
//通过指针引用指向的内容
cout<<*pa<<endl; //引用空间内容：变量名，*地址
*/
//取别名：
//int& pa; 一定要初始化
//定义别名：整型的变量的别名
/*
int& pa=a;
//引用别名和变量名：
cout<<&pa<<" "<<&a<<endl;
cout<<a<<endl;
cout<<pa<<endl;
pa=10000;
cout<<a<<endl;
*/
/*
//取变量：指针变量的别名
int b=79;
int* pz=&b;
//定义别名： 类型& 变量名;
int* & pc=pz;
//引用：引用变量名就是引用内容
cout<<pc<<endl;
cout<<*pc<<endl;
cout<<&pc<<endl;
*/
return 0;
}通过 取别名来实现数据的交换 .
#include<iostream>
using namespace std;
void swap(int& a,int& b)
{
int temp=a;
a=b;
b=temp;
}
int main()
{
int a=1,b=2;
swap(a,b);
cout<<a<<" "<<b<<endl;
}
C++ 的重载 ,就是方法名相同 , 形参不同 .
#include<iostream>
using namespace std;
//折半（二分）查找：整型数组
short finder(int buf[],int ilen,int key)
{
int mid=0;
int left=0,right=ilen-1;
while(left<=right)
{
mid=(left+right)/2;
if(buf[mid]>key)//左侧
right=mid-1;
else if(buf[mid]<key)//右侧
left=mid+1;
else
return mid;
}
}
//重载finder:实现二分查找
short finder(char buf[],int ilen,int key)
{
int mid=0;
int left=0,right=ilen-1;
while(left<=right)
{
mid=(left+right)/2;
if(buf[mid]>key)//左侧
right=mid-1;
else if(buf[mid]<key)//右侧
left=mid+1;
else
return mid;
}
}
int main()
{
char buf[100]="abcdefg";
int buf1[100]={1,2,3,4,5,6,7};
cout<<finder(buf1,7,1)<<endl;
return 0;
}函数模板的使用 .
#include<iostream>
using namespace std;
//C++语言是允许出现同名现象:重载（）
//功能：两整型数相加
//函数名：add
/*
int add(int a,int b)
{
return a+b;
}
float add(double a,double b)
{
return a+b;
}
char add(char a,char b)
{
return a+b;
}
*/
template<typename T>
float add(T a,double b)
{
return a+b;
}
//编译函数时，无法确认类型
int main()
{
//调用函数：函数名（形参匹配） C++是函数名与形参共同决定那一个函数
// cout << add(1,2) <<endl;
// cout<< add(1.5f,6.4f)<<endl;//add(double,double)
//函数模板的公有类型：只有在调用时才能确定
cout<<add(1,2.2)<<endl; //add(int,double) 无法匹配add(int,int)
// cout<<add(1.2,2.2)<<endl;
}通过函数模板来实现 选择排序 .
#include<iostream>
#include<string.h>
using namespace std;
//重载：在同一作用域同名函数
template<typename T>
void swap(T* a,T*b)
{
T temp;
temp=*a;
*a=*b;
*b=temp;
}
template<typename T>
void selectSort(T buf[],int ilen)
{
//选择排序：每一次从未排序中选择最值(监哨值法)，并依次存放
int listen;
int i=0,j;
for(i=0;i<ilen-1;i++)
{
listen=i;
for(j=i+1;j<ilen;j++)
{
if(buf[j]>buf[listen])
listen=j;//存放最值的下标
}
//交换：
if(i!=listen)//listen=9
{
swap(buf+i,buf+listen);
}
}
}
int main()
{
//输入输出：cout cin
char buf[100]="qazwsxcderfvbgtyhn";
selectSort(buf,strlen(buf));
cout<<buf<<endl;
return 0;
}