c++基础入门知识点总结

前言：面向对象三特性：

1.面向过程：功能分解，自上而下，逐层细化。程序=数据结构+算法

2.面向对象：算法和数据结构被看做一个整体，称为对象。    对象=数据结构+算法

3.封装：数据和方法打包，加以权限说明达到使用数据的目的

4.继承：类之间的相关关系，子类可继承父类的功能特性   避免公用代码的重复开发，较少代码和数据冗杂

5.多态：一个接口多种方法

1.std标准的命名空间

1.    std 中所有的成员名都可以直接使用例如：cout cin   end

2.命名空间的特点：

1.命名空间只能在全局范围内使用   用来解决命名冲突    cout<<A::B::a<<endl;

2.命名空间可以嵌套

3.命名空间的开放性  可以将一个变量添加到原有的命名空间中

4.命名空间中可以添加函数

5.命名空间中的函数可以在外部定义，在内部声明即可，只是使用的时候需要添加命名空间作用域

无名命名空间：意味着命名空间内的标识符只能在本文件内使用，就相当于static，使其可以作为内部连接

命名空间别名：为命名空间取个别名namespace short=verylong；

using使用命名空间

namespace std;

using namespce std;//从当前位置开始以后出现的变量都从命名空间中找  代价：简化了重复编写但容易造成冲突

在c 语言中  函数重载=函数名      为程序的入口

在c++语言中 函数重载=函数名+参数

总结;

1.  命名空间的定义：不能在函数内部定义命名空间必须在全局

2.  使用命名空间的成员  最安全的方式   命名空间名::成员名

3.  using namespace命名空间名；使用整个命名空间

4.  单独  使用命名空间中具体的成员：using 命名空间名::成员名

3.全局变量检测增强

C语言：int a =10；//有赋值定义     int a ;//声明

c++语言：int a；表示定义不会把它当作声明

4.c++语言参数中的变量和函数必须添加类型

5.c语言中如果没有类型可以写void

6.c++严格的类型转换：不同类型的变量是不能直接赋值的，需要进行相应的强转

7.struct结构体语法的增强

1.c语言中使用struct 必须使用关键字struct

2.C++中使用struct不用必须使用struct

3.c语言中的结构体只能定义成员变量，不能定义成员函数，c++结构体中既可以定义局部变量，也可以定义成员函数。

8.新增的bool类型关键字

1.    真1假0

2.    字节大小1个字节

9.三目运算符的增强

1.    a>b?a:b;

2.    C语言的三目运算符返回值为a/b的数据值，为右值，不能被赋值

3.    c++语言中三目运算符返回值为a/b变量本身，结果为引用，为左值，可以被赋值

10.const的语法增强

不变的常数，用来限定一个变量不允许改变，它将一个对象转换成一个常量

1、c语言总结：

1、const是一个不能改变的普通变量，是一个只读变量，编译器是会给这个变量分配内存空间的

2、它是一个全局只读变量，是与外部连接的，其他源文件可以使用该变量，只是其他源文件使用的时候需要使用extern，作用是将内部连接变为外部连接，此处为声明，不能赋值。

3、在栈区修饰的const变量可以通过指针修改变量的值，如果是在全局区不可以通过指针修改变量的值。

2、C++总结

1、const int data = 10; //data先放入符号表

2、如果对data取地址系统才会给data开辟空间

3、const int a = b;//b是变量名系统直接给a开辟空间而不放入符号表

4、cosnt修饰自定义数据系统为自定义数据开辟空间

11.c++尽量用const替换#define

#define MAX 1024;

1、安全检查：

const有类型，可进行编译器类型安全检查。#define无类型，不可进行类型检查.

2、作用域：

const有作用域，作用域按情况而定，而#define不重视作用域，是默认定义处到文件结尾。如果是定义在指定作用域下有效的常量，那么#define就不能用。

3、命名空间：

宏不能作为命名空间成员，const可以。

12.引用：作为一个已定义变量的别名。

基本语法: Type& ref = val;

1、&在此不是求地址运算，而是起标识作用

2、类型标识符是指目标变量的类型必须在声明引用变量时进行初始化

3、引用初始化之后不能改变，编译器不会再为引用变量开辟空间

4、不能有NULL引用，必须确保引用是和一块合法的存储单元关联，可以建立对数组的引用。

13.  引用对数组起别名：

void test() {
  int arr[5] = { 10,20,30,40,50];//需求:给arr起个别名
  int(&my_arr)[5] = arr; //my_arr就是数组arr的别名
  int i = 0;
  for (i = 0; i < 5; i++) {
  cout << my_arr[i] << " ";
  }
  cout << endl;
}

14.typedef  给数组类型取别名

void test(){
int arr[5] = {10,20,30,40,50];
/ / 1、用typedef 给数组类型取个别名
/ /TYPE_ARR就是一个数组类型（有5个元素每个元素位int）
typedef int TYPE_ARR[5];//myArr是一个数组类型
TYPE_ARR &myArr=arr;int i=o;for (i=o;i<5;i++){
cout<<myArr[i]<<" ";
}
cout<<endl;
}

 15.引用作为函数参数

#include <iostream>
using namespace std;
void swap(int a, int b){
    int temp;
    temp = a;
    a = b;
    b = temp;
}
int main() {
    int i = 3, j = 5;
    swap(i, j);
    cout << "i=" << i << endl << "j=" << j << endl;
    getchar();
    return 0;
}

16.  函数的返回值作为左值

int my_data(void) {
  static int num = 10;
  cout << "num = " << num << endl;
  return num;
}
void test() {
  //函数的返回值作为左值 
  my _data() = 100;//错误
}
int& my_data(void) {
  static int num = 10;
  cout << "num = " << num << endl;
  return num;
}
void test1() {
  //函数的返回值作为右值my _data2() = 2000;
  my _data();
}

17.引用的本质

1.    引用的本质是指针常量

2.    int&ref =val;//Type* const ref =&val;

18.指针引用

#include<iostream>
using namespace std;
#define _CRT_SECURE_NO_DEPRECATE
#pragma warning(disab1e:6011)
//定义一个Teacher结构体
struct Teacher {
  int mAge; 
};
  /*
  Teacher teacher ;定义一个Teacher结构体类型的变量Teacher* teacher;定义一个Teacher结构体类型的指针变量
  Teacher **teacher;定义一个指针指向Teacher指针类型:*teacher结构体*/
//通过指针间接修改teacher的年龄
void func(Teacher* *teacher) {
  *teacher = (Teacher*)malloc(sizeof(Teacher));
  (*teacher)->mAge = 200;//指针变量解引用之后指向mAge并修改其值
}
//引用修改teacher年龄
void func(Teacher*& teacher) {
teacher->mAge = 300;
}
void test01() {
Teacher* teacher = NULL;
func(&teacher);cout << "func(): " << teacher->mAge << endl; free(teacher);
}
int main(){
test01();
return 0;
}                                            

19.  常引用

const Type& ref = val;

字面量不能赋给引用，但是可以赋给const 引用 const修饰的引用不能修改

void test01() {
  int a = 100; const int& ref = a;
  ref = 200;//不能通过编译   表达式必须是可以修改的左值
  a = 1000;//可以通过编译
  cout << a << endl;
  cout << ref << endl;
}
void test02() {
  //不能把一个字面量赋给引用
  //int &ref=100
  //但是可以把一个字面量赋给常引用
  const int& ref = 100;//int temp=200;const int &ret=temp; 
}

20.const引用使用场景

常量引用主要用在函数的形参，尤其是类的拷贝/复制构造函数。将函数的形参定义为常量引用的好处:引用不产生新的变量，减少形参与实参传递时的开销。由于引用可能导致实参随形参改变而改变，将其定义为常量引用可以消除这种副作用。如果希望实参随着形参的改变而改变，那么使用一般的引用，如果不希望实参随着形参改变，那么使用常引用。

//const int& param 防止函数中意外修改数据
void ShowVal(const int& param) {
  cout << "param : " << param << endl;
}

21.内联函数

内联函数是在普通函数前面添加inline关键字，但是必须注意函数体和声明在一起

因为编译器将会检查函数参数列表使用是否正确，并返回值(进行必要的转换)。这些事是预处理器无法完成的。内联函数的确占用空，但是内联函数相对于普通函数的优势只是省去了函数调用时候的压栈，跳转，返回的开销。我们可以理解为内联函数是以时间换空间。

22.类内部的内联函数

为了定义内联函数，通常必须在函数定义前面放一个inline关键字。但是在类内部定义内联函数时并不是必须的。任何在类内部定义的函数自动成为内联函数。

class Person {
public:
  Person() { cout << "构造函数!" << endl; }
  inline void PrintPerson() { 
cout << "输出 Person! " << endl; 
}//类内inline关键字可有可无
}

23.  内联函数与编译器

内联函数并不是何时何地都有效的，对于任何类型的函数，编译器会将函数类型(包括函数名字，参数类型，返回值类例)放入到符号表中。同样，当编译器看到内联函数，并且对内联函数体进行分析没有发现错误时，也会将内联函数放入符号表。当调用一个内联函数的时候，编译器首先确保传入参数类型是正确匹配的，或者如果类型不正完全匹配，但是可以将其转换为止确类型，并且返回值在目标表达式里匹配正确类型，或者以转换为目标类型，内联函数就会直接替换函数调用，这就消除了函数调用的开销。假如内联函数是成员函数，对象this指针也会被放入合适位置。类型检查和类型转换、包括在合适位置放入对象this指针这些都是预处理器不能完成的。

24.内联函数局限性情况

c++内联编译会有一些限制，以下情况编译置可能考虑不会将函数进行内联编译:

1、不能存在任何形式的循环语句

2、不能存在过多的条件判断语句

3、函数体不能过于庞大不能对函数进行取址操作

25.内联函数的用处

为了保持预处理宏的效率乂增加安全性，而且还能像一般成员函数那样可以在类里访问自如，c++引入了内联函数(inline function).

内联函数为了继承宏函数的效率，没有函数调用时开销，然后又可以像普通函数那样，可以进行参数，返回值类型的安全检查，乂可以作为成员函数。

25.1、参数完整性

#define ADD(x,y ) x+y
inline int Add(int x, int y) {
  return x + y;
}
void test() {
  int ret1 = ADD(10，20) * 10;//希望的结果是300
  int ret2 = Add(10, 20) * 10;//希望结果也是300
  cout << "ret1: " << ret1 << endl; 1 / 210
  cout << "ret2 : " << ret2 << endl; / / 300
}

25.2、逻辑的处理

#define COMPARE(x,y) ((×) < (y)?(×) : (y))
int Compare(int x, int y) {
  return x < y ? x : y;
}
void test() {
  int a = 1; int b = 3;
  //cout << "COMPARE(++a， b): " << COMPARE(++a，b) << endl; // 3
  cout << "Compare( int x,int y):" << Compare(++a， b) << endl;//2
}

25.3、作用域

预定义宏的数没有作用域概念，无法作为一个类的成员函数，也就是说预定义宏没有办法表示类的范围。

26.函数的默认参数

26.1、函数的默认参数

//函数的默认参数  指定x的默认值为10 y默认值为20

int my _add(int x = 10, int y = 20) {
  return x + y;
}
void test() {
  //如果函数传参那么各自的默认参数将无效
  cout << "my _add = " << my _add(100, 200) << endl; / / 300
  //如果某个参数未被传参将启用默认值x=100 y使用默认值20
  cout << "my _add = " << my _add(100) << endl; / /120
  //如果两个参数都未传参那么 x=10  y=20
  cout << "my _add = " << my _add() << endl; / /30
}

26.2、注意点

1、新数的默认参数从左向右，如果一个参数设置了默认参数，那么这个参数之后的参数都必须设置默认参数。

2、如果函数声明和函数定义分开写，即分文件编写，函数声明和函数定义不能同时设置默认参数，声明的时候传入参数即可。

转载请注明：XAMPP中文组官网 » c++基础入门知识点总结