C——编程思想——函数设计——流程图

C++——面向对象思想——类的设计——抽象——类图（UML)

1、C++调用 #include <iostream> 为预处理命令

using namespace std;即使用标准名空间中的内容

iostream为一个类，包括 istream类——输入流类；ostream类——输出流类

cin（输入流对象）——istream

cout（输出流对象）——ostream

“<<”为输入运算符，“>>”为输出运算符

#include<iostream>
using namespace std;

void main()
{
  int a;
  cin>>a;
  cout<<a<<endl;
}

2、命名空间——解决词穷问题

 实现同一程序内，函数命名相同问题

namespace AA
{
  void sort()
  {
  cout<<"AA::sort()"<<endl;
  }
}

namespace BB
{
  void sort()
  { 
  cout<<"BB::sort()"<<endl;
  }
}

//若同一用AA中函数
using namespace AA;

void main()
{
  sort();//AA
  AA::sort();
}

3、<> 与 “” 的区别

 <>先去系统目录中找头文件，如果没有在到当前目录下找。所以像标准的头文件 stdio.h和 stdlib.h等用这个方法。 
  ""首先在当前目录下寻找，如果找不到，再到系统目录中寻找。 这个用于include自定义的头文件，让系统优先使用当前目录中定义的。

4、C和C++中struct的区别

（1）C中不可以为空,Student为结构体名，不可以包含出现函数

（2）C++可以为空，大小为1（1,为占位符），Student可以作为类型名,可以有函数

struct Student
{
};

5、结构体大小计算

内存对齐：与结构体内基本数据类型较大的对齐

struct Student
{
  char c;// 1->4
  int a;// 4
  short b;// 2->4
};//12

struct Student
{
  char c;// 1->2
  short b;// 2
  int c;// 4
};//8

struct Student
{
  int a;// 4
  char b[5];// 5->8
};//12

struct Student
{
  int a;// 4
  char b[5];// 5->8  4+8->16
  double c;//8
};//24

6、类——抽象出来的，将现实生活中实实在在的一些实体的共性抽象出来，形成一个类型。
将不同类型的数据以及与这些数据相关的操作封装在一起，构成一个新的数据类型，现实中不存在，不占用内存单元。

类=属性+函数

访问权限——public,protected,private

在外界不能访问保护和私有

class Clock//类名，一般大写
{
public://与外界接触的操作设置为公有
	void Set()
	{
		m_hour = 20;
		m_minute = 10;
		m_second = 40;
	}
	void Show()
	{
		cout << m_hour << ":" << m_minute << ":" << m_second << endl;
	}
//protected://与继承有关,在继承之前protected可以不用
	//int m_test;
private://将属性设置为私有
	int m_hour;
	int m_minute;
	int m_second;
};
void main()
{
	Clock c;//对象
	/*在外界不能访问保护和私有
	c.m_test=10//error
	c.m_hour=20;//error
	*/
	c.Set();
	c.Show();
}

7、函数重载

（1）函数名相同（在同一个作用域）

（2）函数的参数列表不同（参数的类型个数，个数，顺序）

（3）和函数返回值无关

（4）和常成员函数无关

struct AA
{
  void fn(int a,int b)//AA::fn
{
}
  void fn(int a)
{
}
};

void fn()
{
}

void fn(int n)
{
}

void fn(int a,int b)
{
}

int fn()//error,不能仅通过函数返回值确定是否重载，和函数返回值无关
{
}

8、引用——实体的别名

（1）在声明时必须初始化

（2）没有空引用

（3）不能改变 

void main()
{
  int a=10;
  int &b=a;//b是a的引用，即b是a的别名
  b=20;//a的值改变为20
  //a,b共用一段内存地址
}

引用和指针的区别：

（1）引用必须初始化，指针如果不初始化就是野指针

（2）指针可初始化为空，引用不可为空

（3）引用大小和实例的大小一样，指针大小永远为4

（4） 指针可以修改，引用不能改变

9、值类型  指针类型  引用类型

swap函数四种不同类型

（1）不同的时间里修改了不同的内存单元中的内容——实参和形参不同的内存单元

形参变了，实参没变，两者内存空间不同（在不同的时间里，修改了不同内存的值）

void swap(int a, int b)
{
    int t = a;
    a = b;
    b = t;
}

（2） 不同的时间里修改了不同的内存单元，没有对内容做修改——实参和形参内存单元相同

没变，只交换了a,b所指向的地址，x,y的值没变

void swap(int* a, int* b)
{
    int* t = a;
    a = b;
    b = t;
}

（3）不同时间里修改了同一段内存单元中的内容——实参和形参内存单元相同，并修改了内容

x,y改变，交换了a,b所指向的地址的值

void swap(int* a, int* b)
{
    int t = *a;
    *a = *b;
    *b = t;
}

（4）不同时间里修改了自己本身

改变

void swap(int& a, int& b)
{
    int t = a;
    a = b;
    b = t;
}

int main()
{
    swap(x, y);
}

10、指针

void main()
{
    int arr[] = { 1,1,1,1 }; 
    int* p = (int*)arr;
    printf("*p=%d\n", *p);//1000000010000000100000001->16843009
}

 *p——从p所指向的首地址开始，以p的基类型所占的字节数为偏量，将内存地址的内存取出来

 

11、const

在C中，const是只读的意思

 C++中，const变成常量

（1）const可以定义一个常量

（2）const可以定义函数参数——健壮性以及可读性

（3）const可以定义函数的返回值

（4）const可以定义常成员函数一类 

+const则左值不能使用

int &fn(int b) //返回值为引用作为左值
{
  return b;
}
//仅为值传递，不改变a的值
void main()
{
  int a=10;
  fn(a)=30;
}

int &fn(int *b)
{
  return *b;
}
//改变，传递为a本身
void main()
{
  int a=10;
  fn(&a)=30;
}

以const 在类中为例

class A
{
public:
	void Set(int i = 0, int j = 0)
	{
		m_i = i;
		m_j = j;
	}
	int Get_I() const  //常成员函数——不能修改本类数据成员的值,不能修改m_i,m_j
	{
		//m_i++;//error
		cout << "geti const" << endl;
		return m_i;
	}
	int Get_I()//常成员函数和非常成员函数可以构成重载
	{
		m_i++;
		return m_i;
	}
	int &GetJ()//返回m_j引用
	{
		return m_j;
	}
private:
	int m_i;
	int m_j;
};
void main()
{
	const A b;
	b.Get_I();//常成员函数
	A a;
	a.Set(10, 20);
	cout << a.m_i << endl;//私有函数在外界不能输出，可利用Get_I返回m_i的值
	cout << a.Get_I() << endl;
	//值返回不能作为左值
	a.GetJ() = 40;//可改m_j的值
	//const int &Get_j 不能作为左值
}

 

不用判断如何输出两个数中较大值？

(a+b+abs(a-b))/2

将两个数之差，补给两个数之和