以下内容部分整理自网络，部分为自己面试的真题。
C中，内存分为5个区：堆(malloc)、栈(如局部变量、函数参数)、程序代码区（存放二进制代码）、全局/静态存储区（全局变量、static变量）和常量存储区（常量）。此外，C++中有自由存储区（new）一说。
全局变量、static变量会初始化为缺省值，而堆和栈上的变量是随机的，不确定的。
总的来说，堆是C语言和操作系统的术语，是操作系统维护的一块动态分配内存；自由存储是C++中通过new与delete动态分配和释放对象的抽象概念。他们并不是完全一样。
从技术上来说，堆（heap）是C语言和操作系统的术语。堆是操作系统所维护的一块特殊内存，它提供了动态分配的功能，当运行程序调用malloc()时就会从中分配，稍后调用free可把内存交还。
而自由存储是C++中通过new和delete动态分配和释放对象的抽象概念，通过new来申请的内存区域可称为自由存储区。
基本上，所有的C++编译器默认使用堆来实现自由存储，也即是缺省的全局运算符new和delete也许会按照malloc和free的方式来被实现，这时藉由new运算符分配的对象，说它在堆上也对，说它在自由存储区上也正确。
程序编译的过程中就是将用户的文本形式的源代码(c/c++)转化成计算机可以直接执行的机器代码的过程。主要经过四个过程：预处理、编译、汇编和链接。具体示例如下。
一个hello.c的c语言程序如下。
#include <stdio.h>
int main()
{
printf("happy new year!\n");
return 0;
}其编译过程如下：
负数比较容易，就是通过一个标志位和补码来表示。 拓展问题：
对于浮点类型的数据采用单精度类型（float）和双精度类型(double)来存储，float数据占用32bit,double数据占用64bit,我们在声明一个变量float f= 2.25f的时候，是如何分配内存的呢？
如果胡乱分配，那世界岂不是乱套了么，其实不论是float还是double在存储方式上都是遵从IEEE的规范的，float遵从的是IEEE R32.24 ,而double 遵从的是R64.53。更多可以参考浮点数表示。
无论是单精度还是双精度在存储中都分为三个部分：
如下结构的代码，
int main(void)
{
...
d = fun(a, b, c);
cout<<d<<endl;
...
return 0;
}调用fun()的过程大致如下：
不是很严谨的来说，左值指的是既能够出现在等号左边也能出现在等号右边的变量(或表达式)，右值指的则是只能出现在等号右边的变量(或表达式)。举例来说我们定义的变量 a 就是一个左值，而malloc返回的就是一个右值。
或者左值就是在程序中能够寻址的东西，右值就是一个具体的真实的值或者对象，没法取到它的地址的东西(不完全准确)，因此没法对右值进行赋值，但是右值并非是不可修改的，比如自己定义的class, 可以通过它的成员函数来修改右值。
归纳一下就是：
用动态存储分配函数动态开辟的空间，在使用完毕后未释放，结果导致一直占据该内存单元即为内存泄露。
这里考察的是c 中的默认类型机制。
主要有三点：
class Screen {
public:
const char cha； //const成员变量
char get() const; //const成员函数
};
const Screen screen； //只读对象不能。c中的const仅仅是从编译层来限定，不允许对const 变量进行赋值操作，在运行期是无效的，所以并非是真正的常量（比如通过指针对const变量是可以修改值的）。
但是c++中是有区别的，c++在编译时会把const常量加入符号表，以后（仍然在编译期）遇到这个变量会从符号表中查找，所以在C++中是不可能修改到const变量的。 补充：
下面我们通过代码来看看区别。 同样一段代码，在c编译器下，打印结果为*pa = 4，a = 4 在c++编译下打印的结果为 *pa = 4， a = 8
int main(void)
{
const int a = 8;
int *pa = (int *)&a;
*pa = 4;
printf("*pa = %d, a = %d", *pa, a);
return 0;
}另外值得一说的是，由于c++中const常量的值在编译期就已经决定，下面的做法是OK的，但是c中是编译通不过的。
int main(void)
{
const int a = 8;
const int b = 2;
int array[a+b] = {0};
return 0;
}int *p = new int(1);
特别的，在C++中，如下的代码，用new创建一个对象(new 会触发构造函数， delete会触发析构函数)，但是malloc仅仅申请了一个空间，所以在C++中引入new和delete来支持面向对象。
#include <cstdlib>
class Test
{
...
}
Test* pn = new Test;
Test* pm = (Test*)malloc(sizeof(Test));C中是直接在变量或者表达式前面加上（小括号括起来的）目标类型来进行转换，一招走天下，操作简单，但是由于太过直接，缺少检查，因此容易发生编译检查不到错误，而人工检查又及其难以发现的情况；而C++中引入了下面四种转换：
拓展 在C++中，普通类型可以通过类型转换构造函数转换为类类型，那么类可以转换为普通类型吗？答案是肯定的。
但是在工程应用中一般不用类型转换函数，因为无法抑制隐式的调用类型转换函数（类型转换构造函数可以通过explicit来抑制其被隐式的调用），而隐式调用经常是bug的来源。
实际工程中替代的方式是定义一个普通函数，通过显式的调用来达到类型转换的目的。
class test{
int m_value;
...
public:
operator int() //类型转换函数
{
return m_value;
}
int toInt() //显示调用普通函数来实现类型转换
{
return m_value
}
}；
int main()
{
...
test a(5);
int i = a; // 相当于 int i = test::operator int(&a)
...
return 0;
}class example{
public:
static int m_int; //static成员变量
};
int example::m_int = 0; //没有static
cout<<example::m_int; //可以直接通过类名调用静态成员变量class example{
private:
static int m_int_s; //static成员变量
int m_int;
static int getI() //静态成员函数在普通成员函数前加static即可
{
return m_int_s; //如果返回m_int则报错，但是可以return d.m_int是合法的
}
};
cout<<example::getI(); //可以直接通过类名调用静态成员变量C++语言支持函数重载，C语言不支持函数重载，函数被C++编译器编译后在库中的名字与C语言的不同，假设某个函数原型为：
void foo(int x, int y);
该函数被C编译器编译后在库中的名字为 _foo, 而C++编译器则会产生像: _foo_int_int 之类的名字。为了解决此类名字匹配的问题，C++提供了C链接交换指定符号 extern “C”。
相同点: 它们的作用是防止头文件被重复包含。 不同点
答：理论上++i更快，实际与编译器优化有关，通常几乎无差别。
//i++实现代码为：
int operator++(int)
{
int temp = *this;
++*this;
return temp;
}//返回一个int型的对象本身
// ++i实现代码为：
int& operator++()
{
*this += 1;
return *this;
}//返回一个int型的对象引用i++和++i的考点比较多，简单来说，就是i++返回的是i的值，而++i返回的是i+1的值。也就是++i是一个确定的值，是一个可修改的左值，如下使用：
cout << ++(++(++i)) << endl;
cout << ++ ++i << endl;可以不停的嵌套++i。 这里有很多的经典笔试题，一起来观摩下：
int main()
{
int i = 1;
printf("%d,%d\n", ++i, ++i); //3,3
printf("%d,%d\n", ++i, i++); //5,3
printf("%d,%d\n", i++, i++); //6,5
printf("%d,%d\n", i++, ++i); //8,9
system("pause");
return 0;
}首先是函数的参数入栈顺序从右向左入栈的，计算顺序也是从右往左计算的，不过都是计算完以后再进行的压栈操作：
上面的分析也是基于VS搞的，不过准确来说函数多个参数的计算顺序是未定义的(the order of evaluation of function arguments are undefined)。笔试题目的运行结果随不同的编译器而异。
这里还有一个 i++ 的典型应用案例。
map<char, int> b = {{'a', 1}, {'b', 2}};
for(auto iter = b.begin(); iter != b.end();){
if(iter->first == 'a'){
b.erase(iter++); // 等价于 auto t = iter; iter = iter + 1; b.erase(t);
}
else{
iter++;
}
}相同点：
不同点：
如下代码中对引用取地址，其实是取的引用所对应的内存空间的地址。这个现象让人觉得引用好像并非一个实体。但是引用是占用内存空间的，而且其占用的内存和指针一样，因为引用的内部实现就是通过指针来完成的。
比如 Type& name；<===> Type* const name。
int main(void)
{
int a = 8;
int &b = a;
int *p = &b; // 等价于 int *p = &a;
*p = 0;
cout<<a; //output 0
return 0;
}在C中三目运算符(? :)的结果仅仅可以作为右值，比如如下的做法在C编译器下是会报错的，但是C++中却是可以是通过的。这个进步就是通过引用来实现的，因为下面的三目运算符的返回结果是一个引用，然后对引用进行赋值是允许的。
int main(void)
{
int a = 8;
int b = 6;
(a>b ? a : b) = 88;
cout<<a; //output 88
return 0;
}数组指针，是指向数组的指针，而指针数组则是指该数组的元素均为指针。
类型名 (*数组标识符)[数组长度]
类型名 *数组标识符[数组长度]
该部分主要摘自：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得到左值的右值引用在汇编层面右值引用做的事情和常引用是相同的，即产生临时量来存储常量。但是，唯一 一点的区别是，右值引用可以进行读写操作，而常引用只能进行读操作。
右值引用支持移动语义的实现，可以减少拷贝，提升程序的执行效率。
下面的代码是没有采用右值引用时的实现。
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;
}运行结果如下。
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(int) // 构造s
Stack(int) // 构造tmp
Stack(Stack&&) // 调用带右值引用的拷贝构造函数，直接将tmp的资源给临时对象
~Stack() // tmp析构
operator=(Stack&&) // 调用带右值引用的赋值运算符重载函数，直接将临时对象资源给s
~Stack() // 临时对象析构
~Stack() // s析构 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 <typename T, typename A1, typename A2>
T* factory(A1& a1, A2& a2)
{
return new T(a1, a2);
}
template <typename T, typename A1, typename A2>
T* factory_new(A1&& a1, A2&& a2)
{
return new T(std::forward<A1>(a1), std::forward<A2>(a2));
}
// demo
int a = 2;
int b = 2;
W* c = factory<w>(a, b); // ok
Z* d = factory<Z>(2, 2); // 错误，2 是右值
W* pw = factory_new<W>(a, b); // ok
X* px = factory_new<X>(2, b); // ok
Y* py = factory_new<Y>(a, 2); // ok
Z* e = factory_new<Z>(2, 2); // ok
W* f = factory_new<W>(2, 2); // 错误, 更多相关内容可以参考：c++——左值、右值、左值引用、右值引用
Object Oriented Programming, 面向对象是一种对现实世界理解和抽象的方法、思想，通过将需求要素转化为对象进行问题处理的一种思想。其核心思想是数据抽象、继承和动态绑定（多态）。 面向对象的意义在于：将日常生活中习惯的思维方式引入程序设计中；将需求中的概念直观的映射到解决方案中；以模块为中心构建可复用的软件系统；提高软件产品的可维护性和可扩展性。
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 <<endl;}
}; 这里特别提一下虚继承。虚继承是解决C++多重继承问题（其一，浪费存储空间；第二，存在二义性问题）的一种手段。比如菱形继承，典型的应用就是 iostream, 其继承于 istream 和 ostream，而 istream 和 ostream 又继承于 ios。
3).多态： 多态是指通过基类的指针或者引用，在运行时动态调用实际绑定对象函数的行为。与之相对应的编译时绑定函数称为静态绑定。多态是设计模式的基础，多态是框架的基础。
更多可以参考下面的代码，比较容易混淆的是赋值操作符，其实区分很简单，在出现等号的时候，如果有构造新的对象时调用的就是构造，不然就是调用赋值操作符。特别注意下面的 b 和 f，一个是拷贝构造，一个是构造。
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;
}对于栈对象或者全局对象，调用顺序与构造函数的调用顺序刚好相反，也即后构造的先析构。对于堆对象，析构顺序与delete的顺序相关。
基类采用虚析构函数可以防止内存泄漏。比如下面的代码中，如果基类 A 中不是虚析构函数，则 B 的析构函数不会被调用，因此会造成内存泄漏。
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;
}但并不是要把所有类的析构函数都写成虚函数。因为当类里面有虚函数的时候，编译器会给类添加一个虚函数表，里面来存放虚函数指针，这样就会增加类的存储空间。所以，只有当一个类被用来作为基类的时候，才把析构函数写成虚函数。
对于 class A，它的拷贝构造函数如下：
A::A(const A &a){}
循环调用。如果拷贝构造函数的参数不是当前类的引用，而是当前类的对象，那么在调用拷贝构造函数时，会将另外一个对象直接传递给形参，这本身就是一次拷贝，会再次调用拷贝构造函数，然后又将一个对象直接传递给了形参，将继续调用拷贝构造函数……这个过程会一直持续下去，没有尽头，陷入死循环。
只有当参数是当前类的引用时，才不会导致再次调用拷贝构造函数，这不仅是逻辑上的要求，也是 C++ 语法的要求。
拷贝构造函数的目的是用其它对象的数据来初始化当前对象，并没有期望更改其它对象的数据，添加 const 限制后，这个含义更加明确了。
另外一个原因是，添加 const 限制后，可以将 const 对象和非 const 对象传递给形参了，因为非 const 类型可以转换为 const 类型。如果没有 const 限制，就不能将 const 对象传递给形参，因为 const 类型不能直接转换为非 const 类型，这就意味着，不能使用 const 对象来初始化当前对象了。
如下图所示，C++的编译环境由如下几部分构成：C++标准库、C语言兼容库、编译器扩展库及编译模块。
#include<iostream> //C++标准库，不带".h"
#include<string.h> //C语言兼容库，由编译器厂商提供值得注意的是，C语言兼容库功能上跟C++标准库中的C语言子库相同，它的存中主要为了兼容C语言编译器，也就是说如果一个文件只包含C语言兼容库（不包含C++标准库），那么它在C语言编译器中依然可以编译通过。
直接上代码吧。下面 f 和 g 是有问题的，这种情况就称为 Most vexing parse。
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，参数无解决办法参考上面的 h， j。
————————————————
本文由哈喽比特于2年以前收录，如有侵权请联系我们。
文章来源：https://mp.weixin.qq.com/s/B4zQhTxl8EL0astDch-G0w
京东创始人刘强东和其妻子章泽天最近成为了互联网舆论关注的焦点。有关他们“移民美国”和在美国购买豪宅的传言在互联网上广泛传播。然而，京东官方通过微博发言人发布的消息澄清了这些传言，称这些言论纯属虚假信息和蓄意捏造。
日前，据博主“@超能数码君老周”爆料，国内三大运营商中国移动、中国电信和中国联通预计将集体采购百万台规模的华为Mate60系列手机。
据报道，荷兰半导体设备公司ASML正看到美国对华遏制政策的负面影响。阿斯麦（ASML）CEO彼得·温宁克在一档电视节目中分享了他对中国大陆问题以及该公司面临的出口管制和保护主义的看法。彼得曾在多个场合表达了他对出口管制以及中荷经济关系的担忧。
今年早些时候，抖音悄然上线了一款名为“青桃”的 App，Slogan 为“看见你的热爱”，根据应用介绍可知，“青桃”是一个属于年轻人的兴趣知识视频平台，由抖音官方出品的中长视频关联版本，整体风格有些类似B站。
日前，威马汽车首席数据官梅松林转发了一份“世界各国地区拥车率排行榜”，同时，他发文表示：中国汽车普及率低于非洲国家尼日利亚，每百户家庭仅17户有车。意大利世界排名第一，每十户中九户有车。
近日，一项新的研究发现，维生素 C 和 E 等抗氧化剂会激活一种机制，刺激癌症肿瘤中新血管的生长，帮助它们生长和扩散。
据媒体援引消息人士报道，苹果公司正在测试使用3D打印技术来生产其智能手表的钢质底盘。消息传出后，3D系统一度大涨超10%，不过截至周三收盘，该股涨幅回落至2%以内。
9月2日，坐拥千万粉丝的网红主播“秀才”账号被封禁，在社交媒体平台上引发热议。平台相关负责人表示，“秀才”账号违反平台相关规定，已封禁。据知情人士透露，秀才近期被举报存在违法行为，这可能是他被封禁的部分原因。据悉，“秀才”年龄39岁，是安徽省亳州市蒙城县人，抖音网红，粉丝数量超1200万。他曾被称为“中老年...
9月3日消息，亚马逊的一些股东，包括持有该公司股票的一家养老基金，日前对亚马逊、其创始人贝索斯和其董事会提起诉讼，指控他们在为 Project Kuiper 卫星星座项目购买发射服务时“违反了信义义务”。
据消息，为推广自家应用，苹果现推出了一个名为“Apps by Apple”的网站，展示了苹果为旗下产品（如 iPhone、iPad、Apple Watch、Mac 和 Apple TV）开发的各种应用程序。
特斯拉本周在美国大幅下调Model S和X售价，引发了该公司一些最坚定支持者的不满。知名特斯拉多头、未来基金（Future Fund）管理合伙人加里·布莱克发帖称，降价是一种“短期麻醉剂”，会让潜在客户等待进一步降价。
据外媒9月2日报道，荷兰半导体设备制造商阿斯麦称，尽管荷兰政府颁布的半导体设备出口管制新规9月正式生效，但该公司已获得在2023年底以前向中国运送受限制芯片制造机器的许可。
近日，根据美国证券交易委员会的文件显示，苹果卫星服务提供商 Globalstar 近期向马斯克旗下的 SpaceX 支付 6400 万美元（约 4.65 亿元人民币）。用于在 2023-2025 年期间，发射卫星，进一步扩展苹果 iPhone 系列的 SOS 卫星服务。
据报道，马斯克旗下社交平台𝕏（推特）日前调整了隐私政策，允许 𝕏 使用用户发布的信息来训练其人工智能（AI）模型。新的隐私政策将于 9 月 29 日生效。新政策规定，𝕏可能会使用所收集到的平台信息和公开可用的信息，来帮助训练 𝕏 的机器学习或人工智能模型。
9月2日，荣耀CEO赵明在采访中谈及华为手机回归时表示，替老同事们高兴，觉得手机行业，由于华为的回归，让竞争充满了更多的可能性和更多的魅力，对行业来说也是件好事。
《自然》30日发表的一篇论文报道了一个名为Swift的人工智能（AI）系统，该系统驾驶无人机的能力可在真实世界中一对一冠军赛里战胜人类对手。
近日，非营利组织纽约真菌学会（NYMS）发出警告，表示亚马逊为代表的电商平台上，充斥着各种AI生成的蘑菇觅食科普书籍，其中存在诸多错误。
社交媒体平台𝕏（原推特）新隐私政策提到：“在您同意的情况下，我们可能出于安全、安保和身份识别目的收集和使用您的生物识别信息。”
2023年德国柏林消费电子展上，各大企业都带来了最新的理念和产品，而高端化、本土化的中国产品正在不断吸引欧洲等国际市场的目光。
罗永浩日前在直播中吐槽苹果即将推出的 iPhone 新品，具体内容为：“以我对我‘子公司’的了解，我认为 iPhone 15 跟 iPhone 14 不会有什么区别的，除了序（列）号变了，这个‘不要脸’的东西，这个‘臭厨子’。
