c,,个人笔记总结
C++ 个人笔记总结
--------------------------------- 王 王 小 小 龙 龙 ---------------
Good luck
Believe yourself
Just go
概述：
一 、 C++ + 语言语法基 础 (6)
1.从 C 到 C++的过渡 2.类和对象 3.操作符重载 4.继承与多态 5.异常和 I/O 流
二、数据结构和算法
1.基本数据结构，堆栈、队列、链表、二叉树，实现和应用(2) 2.排序和查找算法
三、模板和 和 STL
1.模板语法 2.STL
四、阶段项目
简化的企业管理信息系统(MIS)
第一 课
从 从 C C 到 到 C++ + 的过渡
一、背景介绍
算盘 - 面向硬件的编程 电子计算机 - 机器语言的编程 1010
- 汇编语言的编程 ADD
- 高级语言的编程 Fortran
printf ("%d", 12);
- 结构化程序设计 C/PASCL
顺序、分支、循环、函数
- 面向对象的程序设计 C++/Java/C#
- 面向问题的程序设计 1960 - Algol 60，算法语言,远离硬件，不适合进行系统开发 1963 - 剑桥大学，CPL，在 Algol 60 的基础上增加对系统开发的支
持，复杂，不易掌握，不易使用 1970 - MIT，BCPL，CPL 的精华版，易学易用，太慢，不实用 1972 - Ken Thomposon，B 语言，通过运行时支持优化 BCPL 的性能，缺少类型 1973 - Dennis Ritchie，C 语言，用 C 重新实现 UNIX 内核 1978 - 《The C Programming Language》，第一个 C 语言的事实标准 1989 - ANSI C，C89 1990 - ISO C, C90 1999 - ISO C 修订，C99 197X - Bajarne Stroustrup，simula 早期的面向对象语言，性能低
下，B 语言。
1979 - 贝尔实验室，多核 UNIX 系统仿真，Cpre， 通过扩展宏为 C 语言增加类似 simula 的面向对象机制。C with Class: simula - 类 Alogo 68 - 操作符重载 Ada - 模板、名字空间 Smalltalk - 引用、异常 C 是 C++的子集，C++是对 C 的扩展。
1983 - C++命名 1985 - CFront 1.0，第一款商用 C++编译器 1987 - GNU C++ 1990 - Borland C++ 1992 - Microsoft C++，IBM C++ 1998 - ISO C++98 2003 - ISO C++03 2011 - ISO C++2011/C++11/C++0x
二 、 C++ + 语言的使用领域：
1.游戏开发：强建模能力，性能高。
2.科学计算：FORTRAN，C++算法库。
3.网络和分布式：ACE 框架。
4.桌面应用：VC/MFC，Office，QQ，多媒体 5.操作系统和设备驱动：优化编译器的发明使 C++在底层开发方面可
以和 C 向媲美。
6.移动终端
既需要性能，同时又要有面向对象的建模。
三 、 C++ +比 比 C C 更丰富
1.支持面向对象，将问题域和方法域统一化。宏观面向对象，微观面
向过程。
2.支持泛型编程。
int add (int a, int b) { ... } template<typename T> T add (T a, T b) { ... } 3.支持异常机制。
int func (void) {
... } int main (void) {
if (func () == -1) {
错误处理;
} } 4.操作符重载
四、第一个 个 C++ + 程序
1.编译器：g++，如果用 gcc 需要带上-lstdc++， 指定其使用标准 c++的运行库。
2.源文件扩展名：.cpp/.cc/.C/.cxx/.c++，最好用.cpp
3.头文件：#include <iostream>
大多数标准库头文件都没有.h 后缀。
4.输出：cout - 标准输出对象
输入：cin
- 标准输入对象
插入运算符：<<
提取运算符：>> 5.std：所有标准库的函数、对象、类型都位于 std 名字空间中。
五、名字空间
1 1. . 对程序中的标识符（类型、函数、变量 ）, ,
按照某种逻辑规则划分成若干组。
2 2. . 定义名字空间
namespace 名字空间名 {
名字空间成员; }
3 3. . 使用名字空间
1 1 作用于限定符：名字空间 名: :: : 名字空间成员，
表示访问特定名字空间中的特定成员。
例子：
#include <iostream> int main (void) {
std ::cout << "Hello, World !" << std ::endl;
int i;
double d;
char s[256];
//
scanf ("%d%lf%s", &i, &d, s);
std ::cin >> i >> d >> s;
//
printf ("%d %lf %s\ \ n", i, d, s);
std ::cout << i << " " << d << " " << s << "\n";
return 0; } ---------------------------------------------------------
2 2 名字空间指令：
using namespace 名字空间名; 在该条指令之后的代码对指令所指名字空间中的所有成员都可见， 可直接访问这些成员，无需加“::”。
例 ：
using namespace std;
3 3 名字空间声明：
using 名字空间名::名字空间成员; 将指定名字空间中的某个成员引入当前作用域， 可直接访问这些成员，无需加“::”。
4 4. . 匿名名字空间
如果一个标识符没有被显示地定义在任何名字空间中， 编译器会将其缺省地置于匿名名字空间中。
对匿名名字空间中的成员通过“::名字空间成员”的形式访问。
5 5. . 名字空间合并
6 6. . 名字空间嵌套
namespace ns1 {
namespace ns2 {
namespace ns3 {
void foo (void) { ... }
}
}
} ns1::ns2::ns3::foo (); using namespace ns1::ns2::ns3; foo (); ---------------
例子：名字空间
#include <iostream> using namespace std; //namespace {
void print (int money) {
cout << money << endl;
} //} //
农行名字空间
namespace abc {
int balance = 0;
void save (int money) {
balance += money;
}
void draw (int money) {
balance -= money;
} } namespace abc {
void salary (int money) {
balance += money;
}
void print (int money) {
cout << "农行：";
::print (money);
} } //
建行名字空间
namespace ccb {
int balance = 0;
void save (int money) {
balance += money;
}
void draw (int money) {
balance -= money;
}
void salary (int money) {
balance += money;
} } int main (void) {
using namespace abc; // 名字空间指令
save (5000);
cout << "农行：" << balance << endl;
draw (3000);
cout << "农行：" << balance << endl;
ccb::save (8000);
cout << "建行：" << ccb::balance << endl;
ccb::draw (5000);
cout << "建行：" << ccb::balance << endl;
using ccb::salary; //
名字空间声明 // using abc::salary;
salary (6000);
cout << "建行：" << ccb::balance << endl;
abc::print (abc::balance);
return 0; }
六 、 C++ + 中的结构、联合和枚举
1 1. . 结构
和 C 语言的不同：
1)定义结构型变量时，可以省略 struct 关键字。
2)结构内部可以定义函数——成员函数。
3)sizeof (空结构) -> 1
例子：
#include <iostream> using namespace std; struct Student {
char name[128];
int age;
void who (void) {
/ // / 成员函数
cout << "我叫" << name << "，今年" << age
<< "岁了。" << endl;
} }; int main (void) {
Student student = {"张飞", 25}, *ps = &student;
student.who ();
ps->who ();
struct A {};
cout << sizeof (A) << endl;
return 0; } ----------------------------------------------------------- 2 2. . 联合
增加了匿名联合的概念。借用联合语法形式， 描述一些变量在内存中的布局方式。
int main() {
UNION
{
int a;
char ch[4];
};
a=0x12345678; } 定义联合变量时，可以不加 union 例子：
#include <iostream> using namespace std; int main (void) {
//
匿名联合
union {
int x;
char c[4] /*= {"A", "B", "C", "D"}*/;
};
cout << (void*)&x << " " << (void*)c << endl;
x = 0x12345678;
for (int i = 0; i < 4; ++i)
cout << hex << (int)c[i] << " ";
cout << endl;
return 0; }
---------------------------------------------------
3 3. . 枚举
枚举是一个独立的数据类型。
C: enum E {a, b, c}; enum E e; e = a; e = 1000; C++: enum E {a, b, c}; E e; e = a; e = b; e = c; b=1;
//
ERROR !
e = 1000; // ERROR !
e = 1;
// ERROR !
例子：
#include <iostream> using namespace std; int main (void) {
enum E {a, b, c};
E e;
e = a;
e = b;
e = c;
// e = 1000; // 报错
// e = 1;
// 报 错
return 0;}
七 、 C++ + 的布尔类型，跟在 在 cout t 后面可以 以 boolalpha
bool b = true; b = false; cout << sizeof (b) << endl; // 1 b = 100; b = 1.234; b = "hello"; b = "A"; 八 、 C++ + 中的运算符别名
&& - and || - or &
- bitand
^
- xor {
- <%
}
- %> [
- <: ]
- :>
九 、 C++ + 中的函数
1 1. . 重载：条件
在同一个作用域中，
函数名相同，
参数表不同的函数，
构成重载关系。
C++编译器会对程序中的函数做换名， 将参数表中的类型信息汇合到函数名中，以保证函数名的唯一。
通过 extern "C"，可以要求编译器不做 C++换名，以方便在 C 语言的模块中使用 C++编译生成的代码。
方式一：
extern "C" {
int add (int a, int b) {
return a + b;
} }
int sub (int a , int b) {
return a - -
b;
} }
} }
方式二：
extern "C" int add (int a, int b, int c) {
return a + b + c;
} } 2 2. . 缺省参数和哑元参数
1)如果调用一个函数时，没有提供实参，那么对应形参就取缺省值。
2)如果一个参数带有缺省值，那么 它后边的所有参数必须都带有缺省值。
3)如果一个函数声明和定义 分开，那么缺省参数 只能放在声明中。
4)避免和重载发生歧义。
5)只有类型而没有名字的形参，谓之哑元。
i++ - operator++ ++i V1: void decode (int arg) { ... } V2: void decode (int) { ... } 例子 子 1 1 ：重载与缺省值
#include <iostream> using namespace std; void foo (int a = 10, double b = 0.01,
const char* c = "tarena");
/ // / 函数 数 1 1
void foo (void) {}
/ // / 函数 数 2 2 / // / 函数 数 1 1 与函数 数 2 2 构成重载关系
void bar (int) {
/ // / 函数 数 3 3
cout << "bar(int)" << endl; } void bar (int, double) {
/ // / 函数 数 4 4
cout << "bar(int,double)" << endl; }
/ // / 函数 数 3 3 与函数 数 4 4 构成重载关系
int main (void) {
foo (1, 3.14, "hello");/ // / 调用函数 数 1 1
foo (1, 3.14);
/ // / 调用函数 数 1 1
foo (1);
/ // / 调用函数 数 1
//
foo (); // 歧义
，可以调用函数 数 2 2 ，但也可以调用函数 数 1 1 ，因为函数 数 1 1 在不提供实参的情况下， 可以取缺省值。
bar (100);
/ // / 调用函数 数 3 3
bar (100, 12.34);
/ // / 调用函数 数 4 4
return 0; } --------------------------------------
例子 子 2 2 ：重载与作用域
#include <iostream> using namespace std; namespace ns1 {
int foo (int a) {
函数 数 1 1
cout << "ns1::foo(int)" << endl;
return a;
} }; namespace ns2 {
double foo (double a) {
函数 数 2 2
cout << "ns2::foo(double)" << endl;
return a;
} }; int main (void) {
using namespace ns1;
//
名字空间指令
using namespace ns2;
//
名字空间指令
cout << foo (10) << endl;
//10
调用函数 数 1 1 ，作用域可见 见 ns2 2 与 与 ns1 1 ，所以与函数 数 2 2 构成重载
cout << foo (1.23) << endl;
//1.23
调用函数 数 2 2 ，作用域可见 见 ns2 2 与 与 ns1 1 ，所以与函数 数 1 1 构成重载
using ns1::foo;
/ // / 名字空间声明 （当同时出现名字指令与名字空间声明，则名字空间声明会隐藏名字空间指令）
cout << foo (10) << endl;
//10 0 ，调用函数 数 1 1 ，只可见名字空间 间 ns1 1 的 的 foo(), , 所以也并不构成重载。
cout << foo (1.23) << endl;
//10 0 ，调用函数 数 1 1 ，只可见名字空间 间 ns1 1 的 的 foo(), , 所以也并不构成重载。
using ns2::foo;
/ // / 名字空间声明
cout << foo (10) << endl;
//10 0 ，调用函数 数 1 1 ，可见名字空间 间 ns1 1 与名字空 间ns2 2 的 的 foo(), , 所以构成重载。
cout << foo (1.23) << endl;
//1.23 3 ，调用函数 数 2 2 ，可见名字空间 间 ns1 1 与名字空间 间 ns2 2 的foo(), , 所以构成重载。
return 0; } --------------------------------------------------------
3 3. . 内联
1)编译器用函数的二进制代码替换函数调用语句，减少函数调用的时间开销。这种优化策略成为内联。
2)频繁调用的简单函数适合内联，而稀少调用的复杂函数不适合内联。
3) 递归函数无法内联。
4)通过 inline 关键字，可以建议编译对指定函数进行内联，但是仅仅是建议而已。
inline void foo (int x, int y){...}
十 、 C++ + 的动态内存分配
malloc/calloc/realloc/free 1.new/delete：对单个变量进行内存分配/释放 2.new[]/delete[]：对数组进行内存分配/释放 例子 ：
new w 与 与 delete
#include <iostream> using namespace std; int main (void) {
// int* pi = (int*)malloc (sizeof (int));
// free (pi);
//c c 中的方法
int* pi = new int;
*pi = 1000;
cout << *pi << endl;
delete pi;
/ // / 一定要释放内存，否则会造成内存泄露，很严重
pi = NULL;
/ // / 不要忘记这个， 虽然不会报错，但是要有好习惯
/*
*pi = 2000;
cout << *pi << endl;
//pi i 指向的内存地址已经被释放，被初始化为指向 向 NULL
*/
pi = new int[10];
for (size_t i = 0; i < 10; ++i)
pi[i] = i;
for (size_t i = 0; i < 10; ++i)
cout << pi[i] << " ";
cout << endl;
delete[] pi;
/ // / 千万记住 住 new[] ] 要用 用 delete[] ] 来释放内存
pi = NULL;
pi = new int (1234);
/ // /用 用 new w 分配内存的同时初始化赋一个值。
cout << *pi << endl;
//1234
delete pi;
pi = NULL;
char buf[4] = {0x12,0x34,0x56,0x78};
pi = new (buf) int;
cout << hex << *pi << endl; //
delete pi;
cout << (void*)pi << " " << (void*)buf << endl;
int (*p)[4] = new int[3][4];
delete[] p;
int (*q)[4][5] = new int[3][4][5];
delete[] q;
return 0; } 十一、引用
1 1. . 引用即别名。
int a = 20; int& b = a; // int* b = &a; b = 10; // *b = 10; cout << a << endl; // 10 2 2. . 引用必须 初始化。
int a; int* p; a = 20; p = &a; int& b; // ERROR ! int& b = a; // OK 3 3. . 引用一旦初始化就不能再引用其它变量。
int a = 20, c = 30; int& b = a; b = c; // c => b/a 4 4. . 引用的应用场景
1 1) ) 引用型参数
a.修改实参 b.避免拷贝，通过加 const 可以防止在函数中意外地修改实参的值，同时还可以接受拥有常属性的实参。
2 2) ) 引用型返回值
int b = 10; int a = func (b);
推荐访问:笔记
上一篇：最美南粤少年简介