C++学习

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include <iostream>
void main()
{
    char c1 = 'yes'; // 截断：1.保留第一个字符 2.保留第二个字符
    std::cout << c1 << std::endl;
	// char* 32bi机器占4位，64占8位，为了搜索整个地址空间
    const char* s1 = "/"; // ==> '/''\0'
    // const char* s2 = '/'; 字符常量->char* 类型不匹配
    const char* s2 = &c1;
    
	// C++ 改进， string 在namespace std中
	std::string s1(3, 'yes');  // s
	std::string s2("yes");   // yes
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

#include <iostream>
#include <vector>
// double average1(int arr[10], int len) {
double average1(int* arr, int len) {  // C：数组退化成指针
	// 传递char数组可以通过计算到'\0'的长度来不借助len
	double result = 0;
    // 形参arr[10]变为int指针,arr[0]为int类型 => len = 4/4 = 1
	// int len = sizeof(arr) / sizeof(arr[0]); 
	for (int i = 0; i < len; i++){
		result += arr[i];
	}
	return result / len;
}
// C++ 改进
double average3(std::vector<int> &v) {
	double result = 0;
	std::vector<int>::iterator it = v.begin();
	// auto it = v.begin();
	for (; it != v.end(); ++it){
		result += *it;
	}
	return result / v.size();
}

double average2DV(std::vector<std::vector<int>>& vv) {
	double result = 0.0;
	unsigned int size = 0;
	for (unsigned int i = 0; i < vv.size(); ++i) {
		for (unsigned int j = 0; j < vv[i].size(); ++j) {
			result += vv[i][j];
			size += 1;
			std::cout << (vv[i][j])+" ";  // +' '自动变为int
		}
		std::cout << std::endl;
	}
		
	return result / size;
}

void main()
{
	int arr[10] = { 10, 20, 30, 40,50 };
	int len = sizeof(arr) / sizeof(arr[0]);
	// std::cout << average1(arr, len) << std::endl;
	std::vector<int> vt{ 12,3,4,5,6,5 };
	std::cout << average3(vt) << std::endl;
	std::vector< std::vector<int>> vv{8,std::vector<int>(12, 3) };
	std::cout << average2DV(vv);

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <iostream>
#include <bitset>
using namespace std;

int main() {
	char a1 = 0x63;  // 0110 0011
	a1 = (a1 >> 4);  // 0000 0110  逻辑右移
	printf("0x%x\n", a1);

	char a2 = 0x95;  // 1001 0101
	a2 = (a2 >> 4);  // 1111 1001  算法右移
	printf("0x%x\n", a2);

	unsigned char a3 = 0x95;  // 1001 0101  C建议先转无符号再右移
	a3 = (a3 >> 4);			  // 0000 1001  逻辑右移
	printf("0x%x\n", a3);

	//const unsigned char priv = 0xff;
	//const unsigned char P_BACKUP = (1 << 7);
	//const unsigned char P_ADMIN = (1 << 8);  // 超过char位数-> =0
	//// 判断用户权限的技巧
	//if (priv & P_BACKUP) cout << "BACKUP" << endl;

	// C++ 改进
	bitset<10> priv = 0xff;
	bitset<10>  P_BACKUP = (1 << 6);
	bitset<10>  P_ADMIN = (1 << 7);  // 超过char位数-> =0
	// 判断用户权限的技巧
	if ((priv & P_BACKUP) == P_BACKUP) cout << "BACKUP" << endl;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include "stdafx.h"

#include <iostream>
using namespace std;
unsigned int MAX_LEN = 11;
int main()
{
	char strHelloworld[] = { "helloworld" };
    // 与strHelloWorld变量共享内存
	char const * pStr1 = "helloworld";       // const char* 不能修改指向的char内容
    // 导致此处赋值后使得pStr1指向的空间可被修改，不能只读
	char* const pStr2 = strHelloworld;		// 不能修改指针值
	char const* const pStr3 = "helloworld";  // const char* const 不能修改内容和指针
	pStr1 = strHelloworld;

	//pStr2 = strHelloworld;              // pStr2不可改
	//pStr3 = strHelloworld;              // pStr3不可改

	unsigned int len = strnlen_s(pStr2, MAX_LEN);
	cout << len << endl;
	for (unsigned int index = 0; index < len; ++index)
	{
		//pStr1[index] += 1;                // pStr1里的值不可改
		pStr2[index] += 1;
		//pStr3[index] += 1;                // pStr3里的值不可改
	}

	return 0;
}

1
2
3
4
5

int a = 12;
int* b = &a;
int** c = &b;
// *有从右向左的结合性，不清楚优先级就用括号
*(*c) = *(b) = a = 12

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

char ch = 'a';
char* cp = &ch;
// ++,--操作符
char* cp2 = ++cp;  
char* cp3 = cp++;
char* cp4 = --cp;
char* cp5 = cp--;

// ++ 左值
//++cp2 = 97;
//cp2++ = 97;

// *++, ++*
*++cp2 = 98; // cp2地址加1后赋值
char ch3 = *++cp2;  // cp2地址加1后将引用的值给左值
*cp2++ = 98;  // 将cp2指向的空间赋值后地址加1
char ch4 = *cp2++;  // 将cp引用的值给左值后地址加1

// ++++, ----操作符等
int a = 1, b = 2, c, d;
//c = a++b;                  // error
c = a++ + b;  // 贪心法
//d = a++++b;             // error
char ch5 = ++*++cp; // 1.先cp地址+1, 2.得到其引用的值, 3.值+1, 4.赋给左值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <string>

int a = 0;                                 // (GVAR)全局初始化区 
int* p1;                                   // (bss)全局未初始化区 
int main()                                 // (text)代码区
{
	int b=1;                               // (stack)栈区变量 32位/64位地址递减/递增 栈区初始化值cc
	char s[] = "abc";                      // (stack)栈区变量
	int*p2=NULL;                           // (stack)栈区变量
	char *p3 = "123456";                   // 123456\0在常量区, p3在(stack)栈区
	static int c = 0;                      // (GVAR)全局(静态)初始化区  
	p1 = new int(10);                      // (heap)堆区变量 32位/64位地址递增 堆区初始化值cd
	p2 = new int(20);                      // (heap)堆区变量
	char* p4 = new char[7];                // (heap)堆区变量 
	strcpy_s(p4, 7, "123456");             // (text)代码区
    return 0;                              // (text)代码区
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// main调用
Complex C; C = a + b;
// 对象函数
Complex Complex::operator+ (const Complex& c) const
{
    // 创建临时对象，并且会触发拷贝构造，浪费时间
	Complex tmp;
	tmp._real = _real + c._real;
	tmp._image = _image + c._image;
	return tmp;
	// 直接返回创建对象
	//return Complex(_real + c._real, _image + c._image);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 1. 自建拷贝构造
Complex::Complex(const Complex& c)
{
	_real = c._real;
	_image = c._image;
	cout << "Complex::Complex(const Complex& c)" << endl;
}
// 2. 定义时赋值（下次都定义时赋值）
Complex C = a + b; // 并且重载符直接return对象 而不是创建临时对象
// 此外可节省调用默认构造函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

Complex& Complex::operator++ () // 前置++ 效率快
{
	_real++;
	_image++;
	return *this;
}
Complex Complex::operator++ (int) // 后置++
{
	//Complex tmp(*this);
	//_real++;
	//_image++;
	//return tmp;
	return Complex(_real++, _image++);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// .h
#include <iostream>
using std::cout;
using std::cin;
friend ostream& operator<<(ostream& os, const Complex &x);
friend istream& operator>>(istream& is, Complex &x);
// .cpp
ostream& operator<<(ostream& os, const Complex &x)
{
	os << "real value is  " << x._real << "  image value is " << x._image;
	return os;
}

istream& operator >> (istream& is, Complex &x)
{
	is >> x._real >> x._image;
	return is;
}
// 防止缓冲区遗留数据：
cin.ignore(numeric_limits<std::streamsize>::max(), '\n'); // 清空缓冲区脏数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

static const int bufferLen = 2048;
bool CopyFile(const string& src, const string& dst)
{
	// 打开源文件和目标文件
	// 源文件以二进制读的方式打开
	// 目标文件以二进制写的方式打开
	ifstream in(src.c_str(), ios::binary);
	ofstream out(dst.c_str(),  ios::binary);
	// 判断文件打开是否成功，失败返回false
	if (!in || !out)
	{
		return false;
	}
	// 从源文件中读取数据，写到目标文件中
	// 通过读取源文件的EOF来判断读写是否结束
	char temp[bufferLen];
	while (!in.eof())
	{
		in.read(temp, bufferLen);
		streamsize count = in.gcount();
		out.write(temp, count);
	}
	// 关闭源文件和目标文件
	in.close();
	out.close();
	return true;
}

1
2
3
4
5
6
7
8
9

#ifndef _SOMEFILE_H_ // 任意专属名称
#define _SOMEFILE_H_
...
#endif //末尾
// 使用宏防止同一个文件被多次包含；
// 优点：可移植性好；缺点：无法防止宏名重复，难以排错
#pragma once
// 使用编译器防止
// 优点：防止宏重复；缺点：可移植性不好

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

String::String(const String &other){  // 拷贝构造函数
	m_data = new char[strlen(other.m_data) + 1];
	if (m_data != NULL)
		strcpy(m_data, other.m_data);
	else
		exit(-1);
}

String& String::operator= (const String &other){  // 赋值函数
	if (this == &other)
		return *this;
	// 释放原有的内容
	delete[ ] m_data;
	// 重新分配资源并赋值
	m_data = new char[strlen(other.m_data) + 1];
	if (m_data != NULL)
		strcpy(m_data, other.m_data);
	else
		exit(-1);
	return *this;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 调用
String s2A(std::move(s1));
String::String(String&& other){  // 移动构造函数  &&右值引用
	if (other.m_data != NULL){
		// 资源让渡
		m_data = other.m_data;
		other.m_data = NULL;
	}
}
// 调用
String s3A;
s3A = std::move(s2A);
String& String::operator=(String&& rhs)noexcept{  // 移动赋值运算符
	if(this != &rhs)
	{
		delete[] m_data;
		m_data = rhs.m_data;
		rhs.m_data = NULL;
	}
	return *this;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class Shape  // 抽象类
{
public:
	virtual double Area() const = 0;// 子类方法实现不一致加上virtual 不创建对象用=0
	virtual void Show() = 0;
	void SetColor(int color) { _color = color; }
	void Display()
	{
		cout << Area() << endl;
	}
private:
	int _color;
};

class Square: public Shape
{
public:
	Square(double len) :_len(len) { }
	void Show() { cout << "Square" << endl; }
	double Area() const
	{
		return _len*_len;
	}
private:
	double _len;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// .h
class Singleton
{
public:
	static const Singleton* getInstance();
	static void DoSomething()
	{
		cout << "Do Something" << endl;
	}
// 将构造和析构函数私有化，防止外部访问
private:
	Singleton();
	~Singleton();

	static Singleton* This; // 使用静态变量帮助解决资源的分配和释放
};
// .cpp
#include "Singleton.h"
// 无法解析的外部符号 "private: static class Singleton * Singleton::This"
Singleton* Singleton::This = nullptr; // = new Singleton();
const Singleton* Singleton::getInstance()
{
	if (!This)
	{
		This = new Singleton;
	}
	return This;
}

Singleton::Singleton(){}
Singleton::~Singleton(){}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// C
#define NULL((void*)0)
// C++
#define NULL
  #ifdef _cplusplus
    #define NULL 0
  #else
    #define NULL((void*)0)
  #endif
#endif
// vc++即使定义指针为NULL，也会转成nullptr即void*

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

class LegacyRectangle  // 旧
{
public:
	LegacyRectangle(double x1) {
		_x1 = x1;
	}

	void LegacyDraw() {
		cout << "LegacyRectangle:: LegacyDraw()" << _x1 << endl;
	}

private:
	double _x1;
};

class Rectangle  // 新接口
{
public:
	virtual void Draw(string str) = 0; //虚函数用于继承给子类
};

// 第一种适配的方式：使用多重继承
class RectangleAdapter: public Rectangle, public LegacyRectangle
{
public:
	RectangleAdapter(double w) : LegacyRectangle(w) {
		cout << "RectangleAdapter" << endl;
	}

	virtual void Draw(string str) {
		cout << "RectangleAdapter::Draw()" << endl;
		LegacyDraw();
	}
};

// 组合方式的Adapter
class RectangleAdapter2 :public Rectangle 
{
public:
	RectangleAdapter2(double w) :_lRect(w) {
		cout << "RectangleAdapter2" << endl;
	}

	virtual void Draw(string str)
	{
		cout << "RectangleAdapter2::Draw()" << endl;
		_lRect.LegacyDraw();
	}
private:
	LegacyRectangle _lRect;
};
// main
RectangleAdapter ra(x, y, w, h);
Rectangle* pR = &ra;

1
2
3

template<Class T1, class T2>
int max(T1 a, T2 b){
    return static_cast<int>(a > b ? a:b);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// C++仿函数模板
template<class T>
struct SortTF
{
	inline bool operator() (T const& a, T const& b) const
	{
		return a < b;
	}
};
template<class T>
struct DisplayTF
{
	inline void operator() (T const& a) const
	{
		cout << a << " ";
	}
};

// C++仿函数模板
int arr4[] = { 4, 3, 2, 1, 7 };
sort(arr4, arr4 + 5, SortF());
for_each(arr4, arr4 + 5, DisplayF());
cout << endl;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 分别是迭代器类型、元素类型、距离类型、指针类型与reference类型
//template<class Iterator>
//struct iterator_traits
//{
//	typedef typename Iterator::difference_type difference_type;
//	typedef typename Iterator::value_type value_type;
//	typedef typename Iterator::pointer pointer;
//	typedef typename Iterator::reference reference;
//	typedef typename Iterator::iterator_category iterator_category;
//}；

1
2
3
4
5
6
7
8

// 目标： 依赖
// 		命令 (前面有个tab)
main: test.o main.o
    g++ test.o main.o -o main
test.o: test.cpp
    g++ -c test.cpp -o test.o
main.o: main.cpp
    g++ -c main.cpp -o main.o

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 变量定义：变量 = 字符串
// 变量使用：$(变量名)
TARGET = main
OBJS = test.o main.o
$(TARGET): $(OBJS)
    g++ $(OBJS) -o $(TARGET)
test.o: test.cpp
main.o: main.cpp
    
.PHONY: clean
clean:
	rm $(TARGET) $(OBJS)
// 不生成目标文件的命令最好使用.PHONY 使其为假想目标
// 扩展用法  /usr/local/bin/系统环境变量（查看echo $path）
install:
	cp ./main /usr/local/bin/mainTest
uninstall:
	rm /usr/local/bin/mainTest

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

TARGET = main // main 和 .o的区别 试试main.o or test
OBJS = test.o
LIB = libtest.so
CXXFLAGS = -c -fPIC

$(TARGET): $(LIB) main.o
	$(CXX) main.o -o $(TARGET) -L. -ltest -Wl,-rpath ./
$(LIB):$(OBJS)
	$(CXX) -shared $(OBJS) -o $(LIB)
$(OBJS):test.cpp
	$(CXX) $(CXXFLAGS) test.cpp -o $(OBJS)
main.o: main.cpp
	$(CXX) $(CXXFLAGS) main.cpp -o main.o

.PHONY: clean
clean:
	rm $(TARGET) $(OBJS)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

TARGET = main
OBJS = test.o
LIB = libtest.so
CXXFLAGS = -c -fPIC
LDFLAGS = -L. -ltest -Wl,-rpath $(@D)

$(TARGET): main.o $(LIB) // 第一个依赖main.o
	$(CXX) $< -o $@ $(LDFLAGS)
$(LIB):$(OBJS)
	$(CXX) -shared $^ -o $@
%.o:%.cpp
	$(CXX) $(CXXFLAGS) $^ -o $@

.PHONY: clean
clean:
	$(RM) $(TARGET) $(OBJS) $(LIB) main.o