C++基础知识（一）

1. c++中#include和 #include的区别

• #include是标准化以前的头文件，现在的保留是为了以前程序代码的使用，但不在官方的标准中，同时中的声明是全局的。
• ＃include是ＡＮＳＩ标准委员会提供的头文件，同时包含在std的名字空间中，因此使用的时候要加上using namespace std;
• 为了程序对C的兼容，#include类似的头文件仍然可以使用，但不包含在std名字空间之中。
• 标准对c的类似的头文件做了改进，同时包含在std的名字空间之中，为了和旧的c头文件的区别，使用#include;

2. c++的常用保留字有哪些？
  bool,catch,class,delete,friend,inline,new,operator,private,protected,public,template,this,throw,true,virtual.
3. c++中的基本数据类型有哪些？
  int,char,wchar_t,float,double,bool,type[],type*,void,struct,union,enum,class,string,vector,list,set,
multiset,multimap,map,pair,stack,deque

4. typedef有哪些使用方式？
  typedef是c/c++代码中经常用到的一个关键字. 他的主要做用是给变量类型定义一个别名. 从而达到代码简化, 促进跨平台开发的目的.

• 变量别名

typedef struct{
int a;
int b;
}MY_TYPE;

这里把一个未命名结构直接取了一个叫MY_TYPE的别名, 这样如果你想定义结构的实例的时候就可以这样:

MY_TYPE tmp;

这是typedef的第一种用法. 比较简单. 就是 typedef 原变量类型 别名 ，相似的例子:

typedef unsigned long DWORD;

typedef void far * LPVOID; //void far *是原变量类型, 表示一个void 型指针(far 在32位系统里面已经没有意义了) 等等

• 函数指针的使用

typedef int (*MYFUN)(int, int);

  这种用法一般用在给函数定义别名的时候.(其实质还是和上面的用法一样的) 上面的例子定义MYFUN 是一个函数指针, 函数类型是带两个int 参数, 返回一个int .
5. 什么是字符串常量？如何使用？

• 字符串常量是一对双引号括起来的字符序列。在c++中，把字符串常量称作c规格的字符串常量，字符串常量总是以’\0’结束。
• 字符串的处理方式：a.字符数组。b.字符指针 c.string类型。
• 字符串的常用函数：

length()  size()  empty()  c_str() substr()
find()  replace()  at()

使用举例：对字符串中的所有错误的”0”替换为”o”;

#include
#include
#include
#include
using namespace std;
//字符串中的替换。
int main(void)
{
  string str="hello world";
  string::size_type pos;
  while(1)
  {
       pos=str.find("0");
    if(pos==string::npos)
    {
     break;
    }
    str.replace(pos,1,"o");
  }
  cout<<str<<endl;
  return 0;
}

6. 什么是枚举常量？如何使用和定义？

• 枚举常量是一种符号常量，它不是变量，不占有内存空间。
• 定义了枚举类型后，可以定义该枚举类型的变量。变量的取值只能是枚举类型定义时规定的值。
• 定义枚举使用enmu {}，如果没有规定，第一个符号常量的枚举值就是0,其它枚举值依次增1。
  使用举例：

int main(void)
{
 enum COLOR {RED,WHITE,BLACK,GREEN,BLUE};
 COLOR color=RED;
 int paint=WHITE;
 cout<<color<<"        "<<paint<<endl;
}

7. 什么是常量？常量如何定义？

• 常量是程序中不变的量，代表固定不变的值。
• 定义常量的时候必须进行初始化；
• 常量名不能放在赋值语句的左边。

8. 左值和右值的区别？

• 左值：是指能够出现在赋值表达式左边的表达式，左值具有存放数据的空间的功能。

• 右值：只能出现在赋值表达式右边的值。

9. sizeof运算符的使用？

• sizeof是运算符，不是函数

• sizeof的操作结果类型为size_t，利用typedef关键对unsigned int 做了别称。它返回操作数或者类型在内存中的字节长度。

• sizeof具有三中使用方式:
  1）sizeof(数据类型)
  2）sizeof(变量名称)
  3）sizeof 变量名称

代码举例如下：

void testSizeof(char ch[100])
{
    //数组做为函数的参数；
        cout<<"ch of function is:"<<sizeof ch<<endl;
}

//字符串中的替换。

int main(void)
{
 
    int a;                  //普通变量
 char * s="ibm";             //指针变量
 char ch[]="hello world";   //字符数组
 char ch2[100]="IBM";      //字符数组
 cout<<"a is:"<<sizeof a<<"s is:"<<sizeof s <<"ch is:"<<sizeof ch<<"ch2 is:"<<sizeof ch2 <<endl;
 testSizeof(ch2);
 return 0;
}

结果：

a is:4s is:4ch is:12 ch2 is:100
ch of function is:4

10. c++中有哪些类型转换？

1、默认类型的转换（隐式类型的转换）
2、强制类型的转换
3、命名类型的转换
命名类型的转换:cast_name(expr);
1） static_cast 静态的转换
2）dynamic_cast 动态的转换
3） const_cast 去掉类型的const特性
4）reinterpre_cast 重新解释

• const_cast
    一个int是可以直接赋给一个const int的，但是一个const int是不可以直接赋给一个int的。这就需要：

int* pi=const_cast<int*>pci;

他还可以把volatile和对齐特性（alignment）去掉。

• reinterpret_cast

  就是把整型（广义的）转换为指针，把指针转换为整型（广义的），把指针转换为另一个类型的指针。

• static_cast
    可以做任何显式的自动转换（implicit cast），也可以做那些自动转换的逆转换，但是不能消除const，volatile和对齐。

• dynamic_cast
    就是根据类型信息来cast。
  示例：去掉const特性

int main(void)
{
   int a=20;
   const  int *p=&a;
   int *p2=const_cast<int *>(p);
   *p2=40;
   cout<<a<<*p<<*p2<<endl;
  
 return 0;
}

//内存的重新解释：

int main(void)
{
   int a=30;
   int *p=&a;
   int b=reinterpret_cast<int>(p);
   cout<<b<<endl;
 return 0;
}

11. 增量表达式和短路表达式？

• 前和后增的区别
• 如果多个表达式用&&进行连接，则一个表达式为假则真个表达式为假
• 如果多个表达式用||进行连接，则一个表达式为真，则真个表达式为真

** 12. const**
作用

1. 指针

• 指向常量的指针（pointer to const）
• 自身是常量的指针（常量指针，const pointer）

2. 引用

• 指向常量的引用（reference to const）
• 没有 const reference，因为引用本身就是 const pointer

使用

// 类
class A
{
private:
    const int a;                // 常对象成员，只能在初始化列表赋值

public:
    // 构造函数
    A() : a(0) { };
    A(int x) : a(x) { };        // 初始化列表

    // const可用于对重载函数的区分
    int getValue();             // 普通成员函数
    int getValue() const;       // 常成员函数，不得修改类中的任何数据成员的值
};

void function()
{
    // 对象
    A b;                        // 普通对象，可以调用全部成员函数、更新常成员变量
    const A a;                  // 常对象，只能调用常成员函数
    const A *p = &a;            // 指针变量，指向常对象
    const A &q = a;             // 指向常对象的引用

    // 指针
    char greeting[] = "Hello";
    char* p1 = greeting;                // 指针变量，指向字符数组变量
    const char* p2 = greeting;          // 指针变量，指向字符数组常量（const 后面是 char，说明指向的字符（char）不可改变）
    char* const p3 = greeting;          // 自身是常量的指针，指向字符数组变量（const 后面是 p3，说明 p3 指针自身不可改变）
    const char* const p4 = greeting;    // 自身是常量的指针，指向字符数组常量
}

// 函数
void function1(const int Var);           // 传递过来的参数在函数内不可变
void function2(const char* Var);         // 参数指针所指内容为常量
void function3(char* const Var);         // 参数指针为常量
void function4(const int& Var);          // 引用参数在函数内为常量

// 函数返回值
const int function5();      // 返回一个常数
const int* function6();     // 返回一个指向常量的指针变量，使用：const int *p = function6();
int* const function7();     // 返回一个指向变量的常指针，使用：int* const p = function7();

** 13. static**
作用

1. 修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区，在 main 函数运行前就分配了空间，如果有初始值就用初始值初始化它，如果没有初始值系统用默认值初始化它。
2. 修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命名空间里的函数重名，可以将函数定位为 static。
3. 修饰成员变量，修饰成员变量使所有的对象只保存一个该变量，而且不需要生成对象就可以访问该成员。
4. 修饰成员函数，修饰成员函数使得不需要生成对象就可以访问该函数，但是在 static 函数内不能访问非静态成员。