c++使用问题汇总

string

取子串

取长度为3的子串
ss_elem = ss.substr(0, 3)

转换

int转string
int与string互转

拷贝

将字符串的一部分拷贝到另一个字符串，string类可以使用构造函数

string(const string &str,string size_type pos=0,size_type n=npos)

替换

C++ string字符串修改和替换方法详解
其中一种使用方法

basic_string& replace (size_type p0, size_type n0, const E *s, size_type n); //使用字符串 s 中的 n 个字符，从源串的位置 P0 处开始替换 1 个字符

获取线程、进程ID

#include <unistd.h>
#include <sys/syscall.h>
#define gettid() syscall(SYS_gettid)

// 获取进程ID
getpid()

// 获取线程ID
gettid()

传值与传址

C++ 传参时传内置类型时用传值(pass by value)方式效率较高
这里汇编代码的主要区别如下

// 传值
00F343EE  mov         eax,dword ptr  //直接将i的值取出来给eax 
00F343F1  add         eax,1  //eax+1 
00F343F4  mov         dword ptr [r],eax
/// 传址
00F3449E  mov         eax,dword ptr  // 跟传指针一样，取i的地址到eax 
00F344A1  mov         ecx,dword ptr [eax]  // 将eax的值取出来 放到ecx中 
00F344A3  add         ecx,1  // ecx值+1 
00F344A6  mov         dword ptr [r],ecx 

对于汇编代码里的[]，说明如下：

在汇编中[]的作用不是单纯的c语言中指针类似,可以分为两种情况。
1.对于变量来说[var]和var作用是一样的。
2.对于寄存器来说就有区别了,[eax]是eax的地址(这里是c语言中的指针) 而不加中括号的eax就是c语言中的变量值了

对于拥有内置类型的STL来说，汇编代码相差不大

int ff(const std::vector<int>& i)
{
	auto sum = 0;
	for (auto ii : i)
	{
		sum += ii;
	}
	return sum;
}
// 反汇编，只截取主要差异部分
mov eax,dword ptr [i]
mov dword ptr [ebp-20h],eax
lea eax,[ebp-34h]
push eax
mov ecx, dword ptr

int ff(std::vector<int> i)
{
	auto sum = 0;
	for (auto ii : i)
	{
		sum += ii;
	}
	return sum;
}
// 反汇编
lea eax,[i]
mov dword ptr [ebp-20h],eax
lea eax,[ebp-34h]
push eax
mov ecx, dword ptr

抽象类

转载自C++学习-抽象类

• C++抽象类是为子类抽象一个基类，抽象类的主要作用是为子类提供相同的属性和方法，其他如果需要在子类中修改方法，需要将其声明为纯虚函数。
• 含有一个及以上纯虚函数的类为抽象类
  需要注意:抽象类虽然不能创建自己的对象，但是可以有自己的指针

class controller
{
	public:
		controller();
		void func() = 0; // 纯虚函数，意味着这是一个抽象类
	protected:
		int x;
		int y;
};
int main()
{
	controller MPCController; //错误，抽象类不能有自己的对象
	controller *p_controller; //正确，抽象类可以有自己的指针
}

虽然抽象类创建了一个抽象类指针，但是该指针依然不能指向自己，只能用来动态的指向子类对象。

（1）如果子类中没有实现纯虚函数，而只是继承基类的纯虚函数，则这个子类仍然还是一个抽象类。
（2）如果子类中给出了基类纯虚函数的实现，则该子类就不再是抽象类，可以建立对象。

Placement new/delete

C++ “让new操作符不分配内存，只调用构造函数”

#include <iostream>
#include <new>

class Test
{
public:
    Test()
    {
        std::cout << "Constructor" << std::endl;
    };
    ~Test()
    {
        std::cout << "Destructor" << std::endl;
    }
private:
    char mA;
    char mB;
};

char* gMemoryCache = (char *)malloc(sizeof(Test));

int main()
{
    {
        Test* test = new(gMemoryCache) Test();
    }
    {
        Test* test = new(gMemoryCache) Test();
        test->~Test();
    }
}
输出：
Constructor
Constructor
Destructor

和其他普通的new不同的是，它在括号里多了另外一个参数。比如：
Widget * p = new Widget; - - - - - - - - - //ordinary new 
pi = new (ptr) int; pi = new (ptr) int;     //placement new

C++ 中为什么没有placement delete

Point* p = new (arena) Point;
// do something
// manipulate a new object
delete p; // Wrong. You release the arena memory
p = new (arena) Point;

// correct method

p->~P();
p = new (arena) Point;

友元

参考材料