c/c 常见面试知识点总结附面试真题-ag真人游戏

4. 指针数组和数组指针的区别

数组指针，是指向数组的指针，而指针数组则是指该数组的元素均为指针。

• 数组指针，是指向数组的指针，其本质为指针，形式如下。如 int (*p)[n]，p即为指向数组的指针，()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p 1时，p要跨过n个整型数据的长度。数组指针是指向数组首元素的地址的指针，其本质为指针，可以看成是二级指针。

类型名 (*数组标识符)[数组长度]

• 指针数组，在c语言和c 中，数组元素全为指针的数组称为指针数组，其中一维指针数组的定义形式如下。指针数组中每一个元素均为指针，其本质为数组。如 int *p[n]， []优先级高，先与p结合成为一个数组，再由int*说明这是一个整型指针数组，它有n个指针类型的数组元素。这里执行p 1时，则p指向下一个数组元素，这样赋值是错误的：p=a；因为p是个不可知的表示，只存在p[0]、p[1]、p[2]…p[n-1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 *p=a; 这里*p表示指针数组第一个元素的值，a的首地址的值。

类型名 *数组标识符[数组长度]

5. 左值引用与右值引用

该部分主要摘自：c 学习笔记

左值引用就是我们通常所说的引用，如下所示。左值引用通常可以看作是变量的别名。

type-id & cast-expression 
// demo
int a = 10
int &b = a
int &c = 10	// 错误，无法对一个立即数做引用
const int &d = 10	// 正确， 常引用引用常数量是ok的，其等价于 const int temp = 10; const int &d = temp	

右值引用是 c 11 新增的特性，其形式如下所示。右值引用用来绑定到右值，绑定到右值以后本来会被销毁的右值的生存期会延长至与绑定到它的右值引用的生存期。

type-id && cast-expression  
// demo
int &&var = 10;	// ok
int a = 10
int &&b = a	// 错误， a 为左值
int &&c = var	// 错误，var 为左值
int &&d = move(a)	// ok, 通过move得到左值的右值引用

在汇编层面右值引用做的事情和常引用是相同的，即产生临时量来存储常量。但是，唯一 一点的区别是，右值引用可以进行读写操作，而常引用只能进行读操作。

6. 右值引用的意义

• 右值引用支持移动语义的实现，可以减少拷贝，提升程序的执行效率。

  下面的代码是没有采用右值引用时的实现。

  class stack
  {
  public:
      // 构造
      stack(int size = 1000) 
  		:msize(size), mtop(0)
      {
  			cout << "stack(int)" << endl;
  			mpstack = new int[size];
      }
  	
      // 析构
      ~stack()
      {
  			cout << "~stack()" << endl;
  			delete[]mpstack;
  			mpstack = nullptr;
      }
  	
      // 拷贝构造
      stack(const stack &src)
  		:msize(src.msize), mtop(src.mtop)
      {
  			cout << "stack(const stack&)" << endl;
  			mpstack = new int[src.msize];
  			for (int i = 0; i < mtop;   i) {
  	   			 mpstack[i] = src.mpstack[i];
  			}
      }
  	
      // 赋值重载
      stack& operator=(const stack &src)
      {
  			cout << "operator=" << endl;
  			if (this == &src)
       	    	return *this;
  			delete[]mpstack;
  			msize = src.msize;
  			mtop = src.mtop;
  			mpstack = new int[src.msize];
  			for (int i = 0; i < mtop;   i) {
  	   			 mpstack[i] = src.mpstack[i];
  			}
  			return *this;
      }
      int getsize() 
      {
  			return msize;
      }
  private:
      int *mpstack;
      int mtop;
      int msize;
  };
  stack getstack(stack &stack)
  {
      stack tmp(stack.getsize());
      return tmp;
  }
  int main()
  {
      stack s;
      s = getstack(s);
      return 0;
  }
  

  运行结果如下。

  stack(int)             // 构造s
  stack(int)             // 构造tmp
  stack(const stack&)    // tmp拷贝构造main函数栈帧上的临时对象
  ~stack()               // tmp析构
  operator=              // 临时对象赋值给s
  ~stack()               // 临时对象析构
  ~stack()               // s析构
  

  执行代码的过程中调用拷贝构造，将内存中的内容逐个拷贝，在 c 11 中可以借助右值引用实现移动拷贝构造和移动赋值来解决这个问题。

  stack(stack &&src)
      :msize(src.msize), mtop(src.mtop)
  {
      cout << "stack(stack&&)" << endl;
      /*此处没有重新开辟内存拷贝数据，把src的资源直接给当前对象，再把src置空*/
      mpstack = src.mpstack;  
      src.mpstack = nullptr;
  }
  // 带右值引用参数的赋值运算符重载函数
  stack& operator=(stack &&src)
  {
      cout << "operator=(stack&&)" << endl;
      if(this == &src)
          return *this;
  	    
      delete[]mpstack;
      msize = src.msize;
      mtop = src.mtop;
      /*此处没有重新开辟内存拷贝数据，把src的资源直接给当前对象，再把src置空*/
      mpstack = src.mpstack;
      src.mpstack = nullptr;
      return *this;
  }
  

  执行结果如下。可以看到，在有拷贝构造和移动拷贝构造函数的时候，优先调用了移动拷贝构造和移动赋值。在移动拷贝构造和移动赋值中直接把资源所有权进行了转移，而非拷贝，这就大大提高了执行效率。

  stack(int)             // 构造s
  stack(int)             // 构造tmp
  stack(stack&&)         // 调用带右值引用的拷贝构造函数，直接将tmp的资源给临时对象
  ~stack()               // tmp析构
  operator=(stack&&)     // 调用带右值引用的赋值运算符重载函数，直接将临时对象资源给s
  ~stack()               // 临时对象析构
  ~stack()               // s析构
  

• 右值引用可以使重载函数变得更加简洁。右值引用可以适用 const t& 和 t& 形式的参数。

  struct w  
  {  
     w(int&, int&) {}  
  };  
    
  struct x  
  {  
     x(const int&, int&) {}  
  };  
    
  struct y  
  {  
     y(int&, const int&) {}  
  };  
    
  struct z  
  {  
     z(const int&, const int&) {}  
  };
  template   
  t* factory(a1& a1, a2& a2)  
  {  
     return new t(a1, a2);  
  } 
  template   
  t* factory_new(a1&& a1, a2&& a2)  
  {  
     return new t(std::forward(a1), std::forward(a2));  
  }  
  // demo
  int a = 2;
  int b = 2;
  w* c = factory(a, b);	// ok
  z* d = factory(2, 2);	// 错误，2 是右值
  w* pw = factory_new(a, b);	// ok
  x* px = factory_new(2, b);	// ok
  y* py = factory_new(a, 2);	// ok
  z* e = factory_new(2, 2);	// ok
  w* f = factory_new(2, 2);	// 错误, 
  

  更多相关内容可以参考：c ——左值、右值、左值引用、右值引用

1. 什么是面向对象（oop）？面向对象的意义？

object oriented programming, 面向对象是一种对现实世界理解和抽象的方法、思想，通过将需求要素转化为对象进行问题处理的一种思想。其核心思想是数据抽象、继承和动态绑定（多态）。
面向对象的意义在于：将日常生活中习惯的思维方式引入程序设计中；将需求中的概念直观的映射到ag真人游戏的解决方案中；以模块为中心构建可复用的软件系统；提高软件产品的可维护性和可扩展性。

2. 解释下封装、继承和多态？

• 1). 封装：
  封装是实现面向对象程序设计的第一步，封装就是将数据或函数等集合在一个个的单元中（我们称之为类）。
  封装的意义在于保护或者防止代码（数据）被我们无意中破坏。
  从封装的角度看，public， private 和 protected 属性的特点如下。

  • 不管哪种属性，内类都是可以访问的
  • public 是一种暴露的手段，比如暴露接口，类的对象可以访问
  • private 是一种隐藏的手段，类的对象不能访问
  • protected 成员：
    • 和 public 一样可以被子类继承
    • 和 private 一样不能在类外被直接调用
    • 特例：在衍生类中可以通过衍生类对象访问，如下代码所示

class base  
{  
public:  
    base(){};  
    virtual ~base(){};  
protected:  
    int int_pro;  
};
class a : public base  
{  
public:  
    a(){};  
    a(int da){int_pro = da;}  
    // 通过 obj 对象直接访问 protected 成员
    void set(a &obj){obj.int_pro = 24;}	
    void printpro(){cout << "the proteted data is " << int_pro <

class a {
public:
	a() {
		m = new int[4]{ 1,2,3,4 };
		std::cout << "constructor" << std::endl;
	}
	~a() {
		if (m != nullptr) {
			delete[] m;
		}
	}
	a(const a& a) {
		this->m = new int[4];
		memcpy(a.m, this->m, this->len * sizeof(int));
		std::cout << "copy constructor" << std::endl;
	}
	// 移动构造
    a(a&& a) : m(a.m) {
		a.m = nullptr; 
		std::cout << "move constructor" << std::endl;
	}
    // 赋值操作符重载
    a& operator= (const a& a) {
        memcpy(a.m, this->m, this->len * sizeof(int));
        std::cout << "operator" << std::endl;
        return *this;
    }
​
private:
    int len = 4;
    int* m = nullptr;
};
​
a geta(a a) {
    return a;
}
​
int main(void)
{
    a a;    // construct
    
    a b = a;    // copy construct
    a c(a); // copy construct
    
    a d;    // construct
    d = a;  // operate
​
    a e = geta(a);  // construct, move construct
​	
	a f = a();	// construct
    return 0;
}

class a{
public:
  a(){}
  //~a(){}
  virtual ~a(){cout << "a disconstruct" << endl;}  // 虚析构
//   ~a(){cout << "a disconstruct" << endl;}  // 析构
};
class b : public a{
public:
  b(){
    // new memory
    // ...
    cout << "b construct" << endl;
  }
  ~b(){
    // delete memory
    // ...
    cout << "b disconstruct" << endl;
  }
};
int main(int argc, char **argv)
{
  a *p = new b;
  
  // some operations
  // ...
  
  delete p;  // 由于基类中是虚析构，这里会先调用b的析构函数，然后调用a的析构函数
  
  return 0;
}

 a::a(const a &a){}

#include  //c  标准库，不带".h"
#include  //c语言兼容库，由编译器厂商提供

class a {
public:
	a() { cout << "const without param" << endl; }
	a(int a) { cout << "const with param" << endl; }
	a(const a& b) { cout << "copy construct" << endl; }
};
int main(void)
{
	a a;	// const(construct) without param
	a b(10);	// const with param
	a c = a();	// const without param
	a d = a(10);	// const with param
	a e(d);	// copy construct
	a f();	
	a g(a());
	a h{};	// const without param
	a i{a{}};	// const without param
	return 0;
}

a f();	// 这个是不是可以看做声明了一个返回值为a的函数，函数名为 f，参数无	
a g(a());	// 这个是不是可以看做声明了一个返回值为a的函数，函数名为 g, 参数类型为函数指针，这个函数指针的返回值类型为a，参数无