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
将两个数之差,补给两个数之和