C++ 基础知识（一）

1.#inclue
#inclue<iostream>中的 # 是预处理标志，要最先处理，即在编译器编译代码之前运行
#inclue<>   和 #include “” 的区别：

< >引用的是编译器的类库路径里面的头文件
" "引用的是你程序目录的相对路径中的头文件
< >一般是引用自带的一些头文件：stdio.h、conio.h、string.h、stdlib.h等等之类的
" "一般是用来引用自己写的一些头文件
如果使用" "，会先在你项目的当前目录查找是否有对应头文件
如果没有，它还是会在对应的类库路径目录里面查找对应的头文件

2.iostream是一个标准库，里面包含了cin和cout,用法就是std::cout<<"hello"；
int x;
std:cin>>x;

还可以这样：
int a,b,c;
std::cin>>a>>b>>c;
std::cout<<a<<" "<<b<<"\n"<<c<<"ddd";
"\n"代表换行，和std:endl是一个意思，但是后者还会刷新缓存区，两者基本一样

3.std是标准的意思。
namespace是命名空间。
<iostream>是头文件。//注意iostream.h
cout,cin,endl是在std命名空间中定义的对象。

4.C++中cout定义在命名空间std中，因此，在使用cout时可以用std::cout这样的方式使用，需要注意的是，cout是ostream类型的对象,而ostream类型定义在iostream头文件中，因此，在使用cout时，还需要使用#include<iostream>. 总结：C++中的命名空间和C#中的意思基本一样，也是相同的作用，用法也差不多，C++中的std是包含了所有的标识符的命名空间，所以一般都要using std，当然也可以直接std::cout 这样调用。

5.system("pause");是暂停的意思，在main函数最后可以不让控制台关闭，用Ctrl+F5也不会关闭,F5调试的话又不加system("pause")的话就会自动关闭。

6.#include "stdafx.h" ？？？

7.#include<iostream>和<iostream.h>的区别：
#include<iostream>中的iostream是C++标准头文件库，而#include<iostream.h>是C中的头文件库，因为C++继承了C的特性，所以也保留了iostream.h这种写法，因为C++引入了namespace,所以用iostream的时候就要开辟命名空间，例如：
#include<iostream>
using namespace std;
用iostream.h的时候就不用命名空间；


8.C++的编译器是从上到下的，例如这段代码
int _tmain()
{
    std::cout <<add(6,9);
    return 0;
}
int add(int x, int y)
{
    return x + y;
}
编译器会报错，但是把add放在上面就不会出错，C++的函数可以不用声明直接定义，但是这不是一个好习惯，最好先声明，原因很简单，声明后编译器就知道这个函数的存在了。声明的时候没有给函数分配内存，而定义就会函数分配内存



9.class类的成员函数的声明和定义不建议全部放在类内，最好定义要放在外面，要加上域符号::
为什么要声明和定义分开？因为写在一起就比如void p（）{std::cout“111”；}；
这样一个函数其实被称为内联函数，就是相当于把函数实现部分拷贝到调用函数的地方，但是一旦{}里面的代码很大，拷贝就会浪费性能，所以声明和定义最好分开，这样就不会去拷贝了

10.头文件用<>包括表示绝对路径，用""表示相对路径，include头文件就可以认为cpp文件包含了头文件中的所有代码。
为什么要用头文件的原因：
（1）.可以被多个cpp文件同事引用，（2）.类的使用者不关心类的细节，只要阅读头文件就可以知道所有信息


11.析构函数和构造函数都不能有返回值，析构函数不能带参数，一个类只能有一个析构函数，而构造函数可以重载，可以带参数。

12.析构函数会在程序结束时执行

13.int *p;    p = 0;  第二句是将p变为空指针； 这样更安全

14.double *p；这是一个double类型的指针，所以这个指针的内存为8个字节，
int *q 这是一个int类型的指针，内存为4字节，而且两者不能相互转换
指针的类型必须与变量的类型相匹配，不然会报错

15.int a = 1;
    int* p;  //int类型指针
    p = &a;  
    cout << *p<<endl; //取指针代表的地址的值，即a的值为1
    cout << p << endl;; //指针p的值 为0057fe10
    cout << &p<<endl;   //指针的地址 0057fe04
    cout << &a << endl;  //a变量的地址，即p的值 0057fe10


16.typedef 的意思就是把。。替换成。。；
double a=9.0 ; double *p=&a;  *p就代表去取指针存放的地址所指向的值，即*p=9.0；


17.为要使用指针：
1.处理堆中存放的大型数据
2.快速访问类的成员数据和函数
3.以别名的方式向函数传递参数

 

18.指针*号靠近变量还是靠近类型：
int   *a;
int*   a;
首先这两种其实是一样的，无伤大雅，但更建议使用第一种，靠近变量
两者意思相同且后者看上去更为清楚:a被声明为类型为 int* 的指针. 但是,这并不是一个好技巧,原因如下:
int* b, c, d;
人们很自然地以为这条语句把所有三个变量声明为指向整形的指针, 但事实上并非如此. 我们被它的形式愚弄了. 星号实际上是表达式 *b 的一部分, 只对这个标识符有用. b 是一个指针, 但其余两个变量只是普通的整形. 要声明三个指针, 正确的语句如下:
int *b, *c, *d;

 

 

19.引用&
int  &ra=a； 引用就是别名，就象库里的小名叫小学生，两者都是指库里
C++之所以增加引用类型， 主要是把它作为函数参数，以扩充函数传递数据的功能。
引用就是常量，只能进行初始化，不能赋值  即int &ra=a;而不能写成 int &ra;ra=a;
引用也可以是类的引用，即代表该类的别名
引用的自身的地址和本尊是一样的，只能修改其保存的值，而不能修改本身

引用很容易与指针混淆，它们之间有三个主要的不同：
1.不存在空引用。引用必须连接到一块合法的内存。
2.一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
3.引用必须在创建时被初始化。指针可以在任何时间被初始化。

20.传参三种方式：
int a=3;int b=4;
（1）按值传递  void swap(int a,int b);传进去之后不改变原来函数外a和b的值，跟C#一样，按值传递会在函数内部创建一个对象的副本，返回的也是一个对象的副本，所以外面的值不会改变.
（2）按地址传递   void swap(int *a,int *b);传入后会改变原来a和b的值
（3）按引用(别名)传递   void swap(int &a,int &b);传入后会改变原来a和b的值,这个&就相当于C#中的ref
尽量使用按别名传递的方式，这样能解决创建副本的问题，也能节省性能

下面的例子，会输出
a=11 b=22
a=22 b=11
a=22 b=11

#include<iostream>
void swap0(int a, int b) //按值传递
{
	int temp = a;
	a = b;
	b = a;
}

void swap1(int& a, int& b)//按引用传递
{
	int temp = a;
	a = b;
	b = temp;
}

void swap2(int* a, int *b)//按地址传递
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

int main()
{
	int a = 11; int b = 22;
	swap0(a, b);
	std::cout << "a=" << a << " " << "b=" << b << std::endl;

	a = 11; b = 22;
	swap1(a, b);
	std::cout << "a=" << a << " " << "b=" << b << std::endl;

	a = 11; b = 22;
	swap2(&a, &b);
	std::cout << "a=" << a << " " << "b=" << b << std::endl;
	return 0;
}

 

21.c++为什么要产生副本？通过汇编理解指针，学习汇编。。

22.栈区和堆区
1.栈区：由编译器自动分配并且自动释放，一般是函数参数和局部变量
2.堆区:一般有程序员分配释放，若不释放，则程序结束时由系统释放
堆是有一串不连续的链表串联起来的内存，速度较慢，容易产生内存碎片，容易使用，在申请内存的时候，系统会遍历一个空闲地址的链表，找到合适的地址分配给使用者
栈是系统自动分配的，程序员不能操作，而且一般较小，一般是函数参数或者局部变量，当函数结束时会释放，栈中的内存是先进后出的。一般第一个进栈的是函数下一行的内存地址，然后从右到左的函数参数，然后是变量，出栈时完全相反，所有变量出栈之后就剩函数下一行的内存地址了，然后自动跳转到下一行执行！

23.内存的三种分配方式：
1． 从静态存储区分配：此时的内存在程序编译的时候已经分配好，并且在程序的整个运行期间都存在。全局变量，static变量等在此存储。
2． 在栈区分配：相关代码执行时创建，执行结束时被自动释放。局部变量在此存储。栈内存分配运算内置于处理器的指令集中，效率高，但容量有限。
3． 在堆区分配：动态分配内存。用new/malloc时开辟，delete/free时释放。生存期由用户指定，灵活。但有内存泄露等问题。

 

24.类的初始化，用new和不用new的区别:
通过下面这个例子,会输出“释放1”，我们可以得出在不使用new创建对象时，对象的内存空间是在栈中的，其作用范围只是在函数内部，函数执行完成后就会调用析构函数，删除该对象。而使用new创建对象是创建在堆中的，必须要程序员手动的去管理该对象的内存空间

#include<iostream>
class TestNew
{
public:
	TestNew(int ID);
	~TestNew();
private:
	int ID;
};

TestNew::TestNew(int ID)
{
	this->ID = ID;//this就是TestNew类
}

TestNew::~TestNew()
{
	std::cout << "释放" << this->ID << std::endl;
}

void Test()
{
	TestNew test(1);
	TestNew * ptest = new TestNew(2);
}

int main()
{
    Test();
    return 0;
}

25.int *p=new int; 在堆中new一个int型 即4字节的内存空间，内存地址保存在p中
*p=3,     修改这块内存中存放的值，改为3
delete p；  释放这块内存空间，但是并没有释放p，p指针还能继续使用，
p=0；      一般是将p清0，以免错误
p=new int;   p还能继续使用
*p=400;       修改这块内存中存放的值，改为400


26.内存泄漏：因为new在堆中的内存不会自动释放，假如保存这块内存的指针是一个函数中的局部变量，当函数执行完毕后，会释放这个指针，那么这块内存就象消失了一样，再也找不回来了，这就叫内存泄漏，必须对这个指针使用delete

27.常见内存错误及对策
1． 内存分配未成功，却被使用。
对策：使用内存之前检查是否分配成功。用p!=NULL判断。
2． 内存分配成功，未初始化就被使用。
内存的缺省值没有统一的标准。大部分编译器以0作为初始值，但不完全是。
对策：内存初始化时赋初值。
3． 内存操作越界。
对策：只能是小心了。
4． 释放了内存，仍然使用。
（1） 使用显示delete和free的野指针。
对策：释放完内存，将指针置为NULL。
（2） 使用隐式delete和free的野指针。主要是指函数返回指向栈内存的指针或引用。
对策：当然是不要返回就可以了。
5． 未释放内存，导致内存泄露。
用new/malloc开辟了内存，没用delete/free释放.
对策：new和delete的个数一定相同；malloc和free的个数一定相同；new[]和[]delete一定对应

28.指针能加减能比较大小

29.将指针定义为常量指针 int *const p=&a；  p是一个常量指针，p本身的值无法修改，但是它指向的地址可以修改

30.假如把const放在前面  const int *p=&a;   p是指向常量的指针，p本身可以修改，但是p所指向的目标不能修改

31.函数的成员变量的初始化

class A
{
public:
   A():x(4),y(7)  //这是一种成员变量的初始化写法，会输出28
   {
    cout<<x*y
   };  
private:
   int x;
   int y;
}

如果把x定义为const的话，就只能使用这种写法给成员变量初始化，因为常量和引用只能被初始化不能被赋值。