一、C语言与C++的区别
1、头文件：
C++：
#include<iostream>
using namespace std;//使用 名空间 std，使用标准的std名空间
//#include<iostream.h>//可以用，不建议，延续C语言比较老的写法
c语言：
#include <stdio.h> //预处理命令
2、思想
C++ – 面向对象；
C – 主要学编程思想 – 函数设计 – 流程图 – ；
C++ – 面向对象思想 – 类的设计 – 抽象 – 类图（用例图、UML）；
UML类图试样例（工具画出来是由颜色的）：
iostream ： istream-- 输入流类 ostream – 输出流类
3、输入输出
cin – istream — 输入流类
cout – ostream — 输出流类
void main()
{
int a;
cin>>a;
cout<<a<<endl;
cout<<"sadasfs"<<endl;
}
endl：结束并换行
cin 和 cout 是函数，不是对象；
“>>” 为输入运算符；
”<<“ 为输出运算符；
4、命名空间
命名空间 – 解决词穷（解决不同文件里出现同命名函数名的问题）
情景示例：
在一个比较大的程序或项目内；写一个排序函数;
不同项目组可能存在一样的名字的函数，
void sort()
{
}
void sort()
{
}
namespace AA
{
void sort()
{
cout<<"AA::sort()"<<endl;
}
}
namespace BB
{
void sort()
{
cout<<"BB::sort()"<<endl;
}
}
using namespace AA;//如果需要使用AA里面的所有东西，需要声明一下名空间
//如果只是想用BB里的个别的，可以不声明，直接使用BB::sort();
void main()
{
sort();
BB::sort();
}
运行结果：
5、#include <>和" "的区别（笔试题）
两者搜索路径不一样；
#include <> — 其中包含的文件是库里面的文件，在安装目录中查找；
#include “” – 其中包含是文件是自己写的，搜索路径：再当前本工程目录底下查找该文件；
6、struct 的区别：
区别
1）、
C语言要求结构体内至少有一个成员；
C++里可以为空，大小为1 – 占位符；
2）、
struct Student
{
};
C语言里：Studnet为结构体名；struct Student为类型；除非typedef；
C++里：Student可以为类型名、类名；
3）、
C语言里：结构内不能包含函数；
C++里：可以有函数；
结构体内存字节对齐:
//如果小的在两边，就把小的分别和大的对齐
struct Student1
{
char a; //1--因为B-->4
int b; //4
short c; //2-->4
};//4+4+4 = 12
//如果小的在一边，就把小的之和和大的对齐
struct Student2
{
char a; //1--因为B-->2
short B; //2
int C; //4
};//2+2+4 = 8
//大的小的，是指基本数据类型，下列int a为大
struct Student3
{
int a; //4
char b[5];//5*1=5 --大的倍数-->8
//数组是构造数据类型；
}; //4+8 = 12
//大的为double c -- 8
struct Student4
{
int a; //4 -- 8
char b[5];//5*1=5--->8
//数组是构造数据类型；
double c;//8
};//8+8+8 = 24
void main()
{
cout<<sizeof(Student1)<<endl;
cout<<sizeof(Student2)<<endl;
cout<<sizeof(Student3)<<endl;
cout<<sizeof(Student4)<<endl;
}
运行结果：
7、类
类 – 抽象出来的，由现实生活中实实在在的一写实体的共性抽象出来，形成一个类型，将不同类型的数据以及与这些数据相关的操作封装在一起，构成一个新的数据类型；现实生活中不存在，不占用内存单元；例如int 用来定义，本身不占用空间。
8、函数重载
1、函数名相同（同一个作用域下）；
2、函数的参数列表不同（参数的类型，个数，顺序）；
3、和函数返回值无关；
4、和常成员函数有关？ — 后面联系类在展开
struct AA
{
void fn(int a,int b) // fn的名字为AA::fn,::表示域
{
}
};
void fn() // ::fn，::前面啥也没有，表示全局
{
cout<<"fn"<<endl;
}
void fn(int n)
{
cout<<"fn(int)"<<endl;
}
void fn(int a,int b)
{
cout<<"fn(int,int)"<<endl;
}
/*
int fn()//error,不能构成重载，不能仅通过函数返回值来确定重载
{
}
*/
void main()
{
fn();
fn(4);
fn(1,2);
}
运行结果：
9、引用 – 实体的别名
1、引用在声明的时候必须先初始化；
2、没用空引用；
3、不能改变；
4、引用大小的为实体大小；
5、引用与实体的生存周期一样；
void main()
{
int a = 10;
//int &b;//error,引用声明的时候必须初始化
int &b = a; //b是a的引用，即是b是a的别名
b = 20;
cout<<a<<endl;
}
引用的地址是相同：
笔试题：引用和指针的区别：
1、初始化：
引用声明的时候必须要初始化，指针可以不初始化，但会出现野指针；
2、NULL；
引用在初始化的时候不能初始化为NULL，但指针可以初始化为NULL；
3、修改：
引用一旦和实体相关起来就不可以修改，指针可以改变；
4、大小：
引用的大小和实体大小一样，指针大小永远是4字节；
相同点：都能通过所关联的变量修改关联的值：
类型：值类型 — 指针类型 — 引用类型
swap：
//不同的时间里，修改了不同的内存单元中的内容 --- 实参和形参不同的内存单元
void swap1(int a,int b)//交换失败
{
int t = a;
a = b;
b = t;
}
//不同的时间里修改了不同的内存单元，没有对内容做修改 --- 实参和形参内存单元相同
void swap2(int *a,int *b)//交换失败，只是改变了指针的指向
{
int *t = a;
a = b;
b = t;
}
//不同的时间里修改了同一段内存单元中的内容 --- 实参和形参的内存单元相同，并修改了内存
void swap3(int *a,int *b)//能交换
{
int t = *a;
*a = *b;
*b = t;
}
//不同的时间里修改了自己本身
void swap4(int &a,int &b)//能交换
{
int t = a;
a = b;
b = t;
}
void main()
{
int x = 10;
int y = 20;
cout<<"原来的值："<<x<<" "<<y<<endl;
swap1(x,y);
cout<<x<<" "<<y<<endl;
swap2(&x,&y);
cout<<x<<" "<<y<<endl;
swap3(&x,&y);
cout<<x<<" "<<y<<endl;
swap4(x,y);
cout<<x<<" "<<y<<endl;
}
运行结果：
相关笔试题：
1、不使用第三方变量交换
方法一：+= 或者 -=
int main()
{
int a = 10;
int b = 20;
//测试溢出
int c = 1000000000;
int d = 2000000000;
printf("%d %d\n",a,b);
printf("%d %d\n",c,d);
//+= 或者 -=
//思路很好，但可能有潜在的溢出风险(仅为可能，但应该问题不大)
a += b;//a =30,b=20
b = a - b;//a=30,b=10
a = a - b;//a=20,b=10
c += d;//a =30,b=20
d = c - d;//a=30,b=10
c = c - d;//a=20,b=10
printf("%d %d\n",a,b);
printf("%d %d\n",c,d);
return 0;
}
结果：
方法二：使用 ^=
int main()
{
int a = 10;
int b = 20;
printf("%d %d\n",a,b);
//可以实现，但可读性不高，难理解
a ^= b;
b ^= a;
a ^= b;
printf("%d %d\n",a,b);
return 0;
}
结果：
2、不用判断输出较大值：
(a+b+abs(a-b))/2 //abs() — 取绝对值
3、指针的运算相关题
相关知识点：
*p — 从p所指向的首地址开始，以p的基类型（指针变量所指向的变量的类型）所占的字节数为偏移量，将内存地址的内容取出来。
void main()
{
char a[]={1,1,1,1,1};
int *p = (int *)a;
printf("*p = %d\n",*p);
}//结果为：00000001000000010000000100000001 --- 16843009
运行结果：
图形化理解：
扩展：
10、const
C语言内：const表示的是只读变量
是只读的意思，修饰的变量是只读变量，还是变量。
C++内：const 变成常量
用法：
1、const可以定义一个常量；
2、const 可以定义函数参数 — 可以提高程序的健壮性和可读性；
例如strcpy，可以一眼看出是将第二参数的值拷贝到第一参数，可读性好；
3、const 可以定义函数的返回值；
4、const可以定义常成员函数 — 需要在类里面；
#include <iostream>
using namespace std;
int& fn1()//函数返回值为引用，可以作为左值
{
int a = 10;
return a;
}
int& fn2(int b)
{
return b;
}
int& fn3(int *b)
{
return *b;
}
void main()
{
fn1()=30;
int a = 10;
fn2(a)= 30;
cout<<a<<endl;
fn3(&a)= 30;
cout<<a<<endl;
}
运行结果：
