ln -s oldFile newFile

ln oldFile  newfILE   //创建的硬链接，两个文件的内容是一样的，索引结点号也是一样；修改任何一个文件的内容，另外一个文件也会修改；删除掉一个文件，会使硬链接数减少1个；

#include <stdio.h>
#define  NUM 3 + 4

//argc参数的个数
//argv将命令行参数记录在下来
int main(int argc, char *argv[])
{
	printf("num * num = %d\n", NUM  * NUM);   
	return 0;
}

       .file   "hello.c"
       .text                                           
       .section    .rodata
   .LC0:
       .string "num * num = %d\n"
       .text
       .globl  main
       .type   main, @function
   main:
   .LFB0:
       .cfi_startproc
       pushq   %rbp
       .cfi_def_cfa_offset 16
       .cfi_offset 6, -16 
       movq    %rsp, %rbp
       .cfi_def_cfa_register 6
       subq    $16, %rsp
       movl    %edi, -4(%rbp)
       movq    %rsi, -16(%rbp)
       movl    $19, %esi
       leaq    .LC0(%rip), %rdi
       movl    $0, %eax
       call    printf@PLT
       movl    $0, %eax
       leave
       .cfi_def_cfa 7, 8
       ret 
       .cfi_endproc
   .LFE0:
       .size   main, .-main
       .ident  "GCC: (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.
       .section    .note.GNU-stack,"",@progbits
   

gcc hello.c -o hello

//函数名字叫做add
//函数的返回类型是int
//函数的参数列表是int,int
//函数的形参是x,y
//大括号范围就是add函数的函数体
//大括号里面的代码是函数的实现
int add(int x, int y)  
{
    return x + y;
}     

#include <stdio.h>
  
//声明了函数add                                        
int add(int, int);
  
int main(int argc, char *argv[])
{
    int a = 10; 
    int b = 20; 

    printf("add(10, 20) = %d\n", add(a, b));
    return 0;
}

//1、编译源代码生成目标文件
gcc -c add.c -o add.o   //add可以自己随便取名xxx,-c选项是只编译不链接

//2、使用ar命令进行打包库
ar crsv libadd.a add.o   //静态库的文件名字叫做libadd.a,约定以lib开头，静态库以.a结尾

//3、将静态库移动到系统的目录中
sudo cp libadd.a /usr/lib

//4、进行链接静态库
gcc main.c -o main -ladd    //-ladd中的l是库的首字母，后面的add与之前的xxx保持一致即可

//测试
./main
接下来可以直接执行main可执行程序了

//注意：此时如果将/usr/lib下的libadd.a文件删除了，也没有影响,可执行程序main也是可以运行的

//1、编译源代码生成目标文件
gcc -c add.c -o add.o -fpic  //add可以自己随便取名xxx,-c选项是只编译不链接,-fpic与位置无关
    
//2、进行打包动态库
gcc -shared -o libadd.so add.o   //动态的文件名字叫做libadd.so,约定以lib开头，动态库以.so结尾
    
//3、将动态库移动到系统的目录中
sudo cp libadd.so /usr/lib
    
//4、进行链接动态库
gcc main.c -o main -ladd    //-ladd中的l是库的首字母，后面的add与之前的xxx保持一致即可
    
//测试
./main
接下来可以直接执行main可执行程序了
  
//注意：此时如果将/usr/lib下的libadd.so文件删除了，执行程序main是会报错

#include <iostream>
  
using namespace std;

int main(int argc,char *argv[])
{
  cout << "Hello World!" << endl;
  return 0;
}

#include <stdio.h>

int main(int argc, char *argv[])
{
    printf("Hello world\n");
    return 0;
}

 #if 0
 ...
 #endif

 //...

 /*...*/

#include <iostream>
  
using namespace std;

int main(int argc,char *argv[])
{
    cin >> number;
    cout << "number = " << number << endl;  //endl，end of line，即换行
    return 0;
}

using namespace std;

namespace <namespace_name>{
...
}//end of namespace <namespace_name>

//标准命名空间也是可以进行扩展的                               
namespace std 
{
	struct MyStruct
    {
        int a;
        double b;
    };
}//end of namespace std

//重要：命名空间是可以进行扩展的
namespace  wd  
{
int	number = 100;
//带命名空间的函数声明                              
void print();
}//end of namespace wd

namespace  wh
{
void display()
{
    cout << "void wh::display()" << endl;
    //想在display中调用wd中的print
    wd::print();
}//end of namespace wh
    
namespace wd
{
int number2 = 200;
void print()
{
    cout << "void wd::print()" << endl;
    //想在print中调用wh中的func
    wh::func();
}//end of namespace wd
    
int main(void)
{
    using wh::display;
    display();
    return 0;
}

namespace {
    int val1 = 10;
    void func();
}//end of anonymous namespace

#include <stdio.h>
#include <iostream>

using std::cout;
using std::endl;

int number = 1; //全局变量number

namespace wd
{

int number = 20; 

void show(int number)
{
    cout << "形参number = " << number << endl; 
    cout << "命名空间中number = " << wd::number << endl; 
    cout << "全局变量number = " << ::number << endl;
    printf("hello,world\n");
    ::printf("hello,world\n");
}

}//end of namespace wd

int main(int argc, char *argv[])
{
    int value = 300;
    wd::show(value);

    return 0;
}

形参number = 300
命名空间中number = 20
全局变量number = 1
hello,world
hello,world

int number = 1;
namespace wd
{
int number = 10;
namespace wh
{
int number = 100;
void display()
{
	cout << "wd::wh::display()" << endl;
}
}//end of namespace wh
void display(int number)
{
    cout << "形参number = " << number << endl;
    cout << "wd命名空间中的number = " << wd::number << endl;
    cout << "wh命名空间中的number = " << wd::wh::number << endl;
}
}//end of namespace wd
int main(void)
{
    using wd::display;
    display();
    return 0;
}

const int number1 = 10;//const关键字修饰的变量称为常量
int const number2 = 20;

const int val;//error 常量必须要进行初始化
number1 = 20; //error 常量是不能赋值的

#define NUMBER 1024
#define MUl(x, y) x * y //error 容易产生字符串替换后的运算顺序错误
#define MUl(x, y) ((x) * (y)) //需要加上括号来保证运算顺序

int number1 = 10;
int number2 = 20;
int number3 = 30;

//常量指针，Pointer to const
const int * p1 = &number1;
*p1 = 100;//error 通过p1指针无法修改其所指内容的值（*p1不能改变）
p1 = &numbers;//ok 可以改变p1指针的指向（p1可以改变）
int const * p2 = &number1; //常量指针的第二种写法

//指针常量，const pointer
int * const p3 = &number1;
*p3 = 100;//ok 通过p3指针可以修改其所指内容的值
p3 = &number2;//error 不可以改变p1指针的指向

//双const，既不能改变指针所指变量的值，也不能改变指针的指向(只读)
const int * const p4 = &number3;
cout << "*p4 = " << *p4 << endl;
*p4 = 20;//error，不可以改变指针所指变量的内容
p4 = &a;//error,不可以改变指针的指向
cout << "*p4 = " << *p4 << endl;

//函数指针
int (*func)()//func指针可以指向返回类型是int，参数为无参的函数

//指针函数
int*  func()//func函数的返回类型是int*，参数为无参

//数组指针
int (*array)[10]//array指针可以指向存放十个int类型数据的数组、

//指针数组
int*  array[10]//array数组可以存放十个int*类型指针

int number = 10;
//引用是一个变量的别名,引用的提出是为了减少指针的使用，操作引用与操作变量本身是等价的。
int &ref = number;
int &ref2;//error 需要进行初始化

//指针作为参数，指针传递
void swap(int *pa, int *pb)
{
    int temp = *pa;
    *pa = *pb;
    *pb = temp;
}

//引用作为参数，引用传递★
void swap(int &x, int &y)
{
    int temp = x;
    x = y;
    y = temp;
}

//变量作为参数，值传递（error），此时不能正确交换
void swap(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
}

int gNumber;//全局变量
int func1() // 当函数返回时，会对temp进行复制
{
    temp = 100;
    return temp;//此处会进行复制操作
}
int &func2()//当函数返回时，不会对temp进行复制，因为返回的是引用
{
    temp = 1000;
    return temp;
}

int &func3()
{
    int number = 1;
    return number;
}//error 不能返回局部变量的引用

int &func4()
{
    int *pInt = new int(1);
    return *pInt;
}//warning 返回new分配的堆空间变量的引用，如果忘记回收会发生内存泄露

void test()
{
    int a = 3, b = 4;
    int c = a + func4() + b;//发生内存泄露
    
    int &ref = func4();
    delete &ref;//回收内存
}

int func(x)
{
    int countx = 0;
    while(x)
    {
        countx++;
        x = x&(x-1);
    }
    return countx;
}

TYPE a = （TYPE）EXPRESSION;

int iNumber = 100；
float fNumber = 0；

fNumber = (float) iNumber；//C风格
fNumber = static_cast<float>(iNumber);//C++风格

void *pVoid = malloc(sizeof(int));
int *pInt = static_cast<int*>(pVoid);
*pInt = 1;

int *pInt = static_cast<int*>(malloc(sizeof(int)));//一步完成

int iNumber = 1;
int *pInt = &iNumber;
float *pFloat = static_cast<float *>(pInt);//error

const int number = 100;
int *pInt = &number;//error
int *pInt2 = const_cast<int *>(&number);
*pInt2 = 30;

number = 100
pInt2 = 30
&number = 0x7fffa1d1282c
pInt = 0x7fffa1d1282c
&pInt = 0x7fffa1d12830

int add(int x, int y)
{
  return x + y;
}

float add(float x, float y)
{
  return x + y;
}

int add(int x, float y)
{
  return x + y;
}
int add(float x, int y)     
{
  return x + y;
}

int add(int x, int y, int z)
{
  return x + y + z;
}

float add(float x, float y, float z)
{
  return x + y + z;
}

void test()
{
    int * pInt= static_cast<int *>(malloc(sizeof(int)));
    memset(pInt, 0, sizeof(int));
    free(pInt);
    pInt = nullptr;
}

g++ -c 3_add.c -o add.o

nm add.o
                 U __cxa_atexit
                 U __dso_handle
                 U free
                 U _GLOBAL_OFFSET_TABLE_
000000000000014d t _GLOBAL__sub_I__Z3addii
00000000000000e9 T main
                 U malloc
                 U memset
0000000000000014 T _Z3addff
0000000000000082 T _Z3addfff
000000000000004a T _Z3addfi
000000000000002e T _Z3addif
0000000000000000 T _Z3addii
0000000000000066 T _Z3addiii
0000000000000104 t_Z41__static_initialization_and_destruction_0ii
00000000000000a6 T _Z4test
...

extern "C"
{
int add(int x, int y)
{
    return x + y;
}
}//end of extern "C"

nm add.o
0000000000000000 T add
                 U __cxa_atexit
                 U __dso_handle
                 U free
                 U _GLOBAL_OFFSET_TABLE_
000000000000014d t _GLOBAL__sub_I_add
00000000000000e9 T main
                 U malloc
                 U memset
0000000000000014 T _Z3addff
0000000000000082 T _Z3addfff
000000000000004a T _Z3addfi
000000000000002e T _Z3addif
0000000000000066 T _Z3addiii
...

#ifdef __cplusplus
extern "C"
{
#endif
int add(int x, int y)
{
    return x + y;
}
#ifdef _cplusplus
}//end of extern "C"
#endif

void func1(int 1 x = 0, int y = 0);

void func1(int x, int y)
{
cout << "x = " << x << endl;
cout << "y = " << y << endl;
}

void func2(int a = 1, int b, int c = 0, int d);//error
void func2(int a, int b, int c = 0, int d = 0);//ok

bool b1 = -100;//true
bool b2 = 100;//true
bool b3 = 0;//false
bool b4 = 1;//true
bool b5 = true;//true
bool b6 = false;//false
int x = sizeof(bool);//1B

int max(int x, int y)
{
return x > y ? x : y;
}

inline int max(int x, y)
{
    return x > y ? x : y;
}

inline void foo(int x, int y);//error 该语句在头文件中
void foo(int x, int y)//实现在.cpp文件中
{
//...
}

inline void foo(int x, in y)//该语句在头文件中
{
//...
}

.
├── add.cc
├── add.h
└── testAdd.cc

#ifndef __ADD_H__ //防止在同一个文件中被多次编译
#define __ADD_H__

//对于内联函数而言，不能分成头文件与实现文件，也就是不能将声明与实现分开，否则在链接的时候，会链接不到函数的实现。
//如果一定要将头文件与实现文件分开，那么可以在头文件中去#include实现文件，可以弥补链接不到add.o的缺陷
inline
int add(int, int);

#include "add.cc"
#endif

inline
int add(int x, int y)
{
    return x + y;
}

#include "add.h"
#include "add.h"
#include <iostream>
#include "add.h"//此时由于有#ifndef __ADD_H__在add.h中的存在，因此只会编译一次

using std::cout;
using std::endl;                                                                       

int main(int argc, char *argv[])
{
    int a = 3, b = 4;
    cout << "add(a, b) = " << add(a, b) << endl;
    return 0;
}

void test()
{
    double x, y;
    cin >> x >> y;
    try
    {
        if(0 == y)
        {
            throw y;
        }
        else
        {
            cout << (x / y) << endl;
        }
    }
    catch(double d)
    {
        cout << "catch(double)" << endl;
    }
    catch(int e)
    {
        cout << "catch(int)" << endl;
    }
}

void Diff()
{
    //字符数组
    char str1[] = "hello";
    char str2[] = {'w', 'o', 'r', 'l', 'd'};
    char str3[] = {'w', 'o', 'r', 'l', 'd','\0'};

    cout << "strlen(str1) = " << strlen(str1) << endl; 
    cout << "strlen(str2) = " << strlen(str2) << endl;
    cout << "strlen(str3) = " << sizeof(str2) << endl;
    
    cout << "sizeof(str1) = " << sizeof(str1) << endl;
    cout << "sizeof(str2) = " << sizeof(str2) << endl;
    cout << "sizeof(str3) = " << sizeof(str2) << endl;
    cout << endl;
    
    //字符指针
    char *pstr = "hello,world";                                                            
    cout << "strlen(pstr) = " << strlen(pstr) << endl;
    cout << "sizeof(pstr) = " << sizeof(pstr) << endl;
    cout << "sizeof(*pstr) = " << sizeof(*pstr) << endl;
    cout << "*pstr = " << *pstr << endl;
}

./a.out
strlen(str1) = 5  //使用strlen时会遇到\0时会自动结束，不包含\0
strlen(str2) = 10 //错误结果 需要手动加上\0作为结尾
strlen(str3) = 5  //与str1相同
sizeof(str1) = 6  //C语言风格的字符串以\0结尾
sizeof(str2) = 5  
sizeof(str3) = 6

strlen(pstr) = 11
sizeof(pstr) = 8  //此处指的是指针的大小
sizeof(*pstr) = 1 //sizeof(*pstr)表示指向的第一个字符的大小
*pstr = h         //*pstr表示指向的第一个字符

//字符数组，类比指针常量int * const p3
str1[0] = 'H';//ok 修改数组中的内容
cout << "str1 = " << str1 << endl;
str1 = nullptr;//error 不能修改指向

//字符指针，类比常量指针const int * p3
char *pstr = "hello,world";
cout << "pstr = " << pstr << endl;
cout << "strlen(pstr) = " << strlen(pstr) << endl;
pstr[0] = 'H';//warning 会发生段错误（Segmentation fault）
pstr = "Lizi" //warning 可以改变指向

g++ 12_string.cc -o string -g //会报warning
gdb ./string

(gdb) n

Program received signal SIGSEGV, Segmentation fault.
0x0000555555554c5a in test () at 12_string.cc:27
27	    pstr[0] = 'H';//error 会发生段错误（Segmentation fault）

//字符指针，类比常量指针const int * p3
const char *pstr = "hello,world";
cout << "pstr = " << pstr << endl;
cout << "strlen(pstr) = " << strlen(pstr) << endl;
pstr[0] = 'H';//error 会发生段错误（Segmentation fault）
pstr = "Lizi" //ok 可以改变指向

//字符检查函数(非修改式操作)
size_t strlen( const char *str );//返回str的长度，不包括null结束符
//比较lhs和rhs是否相同。lhs等于rhs,返回0; lhs大于rhs，返回正数; lhs小于rhs，返回负数
int strcmp( const char *lhs, const char *rhs );
int strncmp( const char *lhs, const char *rhs, size_t count );
//在str中查找首次出现ch字符的位置；查找不到，返回空指针
char *strchr( const char *str, int ch );
//在str中查找首次出现子串substr的位置；查找不到，返回空指针
char *strstr( const char* str, const char* substr );
//字符控制函数(修改式操作)
char *strcpy(char *dest, const char *src);//将src复制给dest，返回dest
char *strncpy(char *dest, const char *src, size_t count);
char *strcat( char *dest, const char *src );//concatenates two strings
char *strncat( char *dest, const char *src, size_t count );

strcat(str1, str3);//error 发生内存踩踏

size_t len = sizeof(str1) + sizeof(str3)
char *ptmp = new char[len]();
strcpy(ptmp, str1);
strcat(ptmp, str3);

using std::string;
using std::cout;
using std::endl;

void string_test()
{
    //C风格字符串转换为C++风格字符串
    string s1 = "hello";
    string s2("world");
    
    //求取字符串长度
    cout << s1.size() << endl;
    cout << s1.length() << endl;
    
    //字符串的遍历
    for(size_t idx = 0; idx != s1.size(); ++idx)
    {
        cout << s1[idx] << " ";
    }
    cout << endl;
    
    //字符串拼接
    string s3 = s1 + s2;
    cout << "s3 = " << s3 << endl;
    
    //查找子串
    size_t pos = s1.find("world");
    
    //截取子串
    string substr = s1.substr(pos);
    cout << "substr = " << substr << endl;、
        
    //string与C风格字符串的转换
    const char *c_str() const;// 返回一个C风格字符串
    const char *data() const;// c++11之后与c_str()效果一致
    size_type copy(char* dest, size_type count, size_type pos = 0) const;//字符串的内容复制或写入既有的C风格字符串或字符数组内
}

#include <stdio.h>

#define X 1024//预处理时替换
int a = 1;//读写段
const int b = 2;//只读数据区（文字常量区）

int main(){//main函数在程序代码区
    static int c = 3;//读写段
    int d =4;//栈区
    const int e = 5;//栈区
    const char *pstr = "Hello";//&pstr在栈区，pstr在只读数据区
    int *p = (int*)malloc(sizeof(int)*10);//&p在栈区，p在堆区
    
    a = b + c + d;
    for(int i = 0; i < 10; i++){
        p[i] = X+i;
    }
    printf("world\n");//printf函数在共享库的存储映射区
    free(p);
    
    return 0;
}

类{
    //属性：特征，即数据类型
    //方法：函数，即成员函数
}

class 类名
{
public://公有数据成员和成员函数
    
protected://保护数据成员和成员函数
    
private://私有数据成员和成员函数
    
}; //千万不要忘了这个分号

#include <string.h>
#include <iostream>

using std::cout;
using std::endl;

class Computer
{
public:
    //成员函数
    void setBrand(const char * brand)
    {
    	strcpy(_brand, brand);//没有考虑内存越界的问题
        //tips：可以用快捷键shift+k查看strcpy，相当于man strcpy，此外想要到不同卷，可以[n], shift+k
    }
    void setPrice(float price)
    {
   		_price = price;
	}
    void print()
    {
        cout << "brand = " << _brand << endl;
        cout << "price = " << _price << endl;
    }
    
private:
    //数据成员
    char _brand[20];
    float _price;
};

int main(int argc, char * argv[])
{
    Computer pc;//通过类来创建对象，无参时不需要加上()，否则是函数声明
    pc.setBrand("Huawei Matebook14");
    pc.setPrice(5600);
    pc.print();
    pc._price = 5500;//error 私有数据不能在类外部用
    return 0;
}

class Empty
{
}//此时有四个成员函数

返回类型 类名::成员函数名(参数列表)
{
	//....
}

class Computer
{
public:
    void setBrand(const char * brand);
    void setPrice(float price);
    void print();
    
private:
    char _brand[20];
    float _price;
};

void Computer::setBrand(const char * brand)
{
    strcpy(_brand, brand);//没有考虑内存越界的问题
}
void Computer::setPrice(float price)
{
    _price = price;
}
void Computer::print()
{
    cout << "brand = " << _brand << endl;
    cout << "price = " << _price << endl;
}

#ifndef _COMPUTER_H_
#define _COMPUTER_H_

class Computer
{
public:
    void setBrand(const char * brand);
    void setPrice(float price);
    void print();
    
private:
    char _brand[20];
    float _price;
};

#endif

#include "Computer.h"
#include <string.h>
#include <iostream>

using std::cout;
using std::endl;

void Computer::setBrand(const char * brand)
{
    strcpy(_brand, brand);//没有考虑内存越界的问题
}
void Computer::setPrice(float price)
{
    _price = price;
}
void Computer::print()
{
    cout << "brand = " << _brand << endl;
    cout << "price = " << _price << endl;
}

#include "Computer.h"

int main(int argc, char * argv[])
{
    Computer pc;//通过类来创建对象
    pc.setBrand("Huawei Matebook14");
    pc.setPrice(5600);
    pc.print();
    
    return 0;
}

class Point
{
public:
    //...
    Point(int ix, int iy)//构造函数名需要与类名相同
    : _ix(ix)//等价于int _ix = ix的语法
    , _iy(iy)
    {
        cout << "Point(int,int)" << endl;
    }
    
    Point()//构造函数可以重载
    {
        cout << "Point()" << endl;
        _ix = 0;//此时不是初始化，而是赋值
        _iy = 0;
    }
    
    void print()
    {
        cout << "(" << _ix
        << "," << _iy
        << ")" << endl;
    }
private:
    int _ix;
    int _iy;
};

int main(void)
{
    Point pt(1, 2);
    pt.print();
    
	Point pt2();
    pt2.print();
    
    return 0;
}

Point()//编译器默认提供的构造函数，不会对值进行初始化
{
}

Point(int ix = 0, int iy = 0);//在声明中设置默认参数

Point(int ix, int iy)
: _ix(ix)
, _iy(iy)
{
    cout << "Point(int,int)" << endl;
}

class Computer
{
public:
    Computer(const char *brand, float price);
    void print();
    
private:
    char *brand;
    float _price;
};

#include "Computer.h"
#include <string.h>
#include <iostream>

using std::cout;
using std::endl;

Computer::Computer(const char *brand, float price)
: _brand(new char[strlen(brand) + 1]()//申请空间
, _price(price)
{
    strcpy(_brand, brand);//此时已经考虑了内存越界
}

void Computer::print()
{
    cout << "brand = " << _brand << endl;
    cout << "price = " << _price << endl;
}

#include "Computer.h"

int main(int argc, char * argv[])
{
    Computer pc("Huawei Matebook14", 6800);
    pc.print();
    return 0;
}

class Foo
{
public:
    Foo(int a)
    : _iy(a)
    , _ix(_iy)//_ix先被初始化，说明只与被声明的顺序有关
    {
    	cout << "Foo(int)" << endl;
    }
private:
    int _ix; //在声明时，_ix在前
    int _iy;
};

Computer::~Computer()
{
    
}

class Computer
{
public:
    Computer(const char *brand, double price)
    : _brand(new char[strlen(brand) + 1]())
    , _price(price)
    {
        cout << "Computer(const char *, double)" << endl;
    }
    
    ~Computer()//对象销毁时自动调用析构函数，不可重载
    {
        cout << "~Computer()" << endl;
        delete [] _brand;//调用两次析构函数时，第二次会输出错误结果
        _brand = nullptr;//如果没有这一句，调用两次析构函数时会发生double free错误
    }

private:
    char *_brand;
    double _price;
};

#include "Computer.h"

Computer g_pc("Macbook", 10000);//g_pc是全局变量，在读写段，在运行main函数之前被创建，在main函数结束之后被销毁
int main(int argc, char * argv[])
{
    Computer pc_stack("Huawei Matebook14", 6800);//pc_stack在栈区，将pc称作栈对象，生命周期从到达该对象定义处到作用域结束
    Computer *pc__heap = new Computer("Xiaomibook",6000); //pc__heap是堆对象，不会自动调用析构函数
    
    pc_stack.print();
    
    delete pc__heap;
    pc__heap = nullptr;
    
    return 0;
}

Point::Point(const Point &rhs)
: _ix(rhs._ix)//此时属于特别情况能够调用其他对象的私有数据成员
, _iy(rhs._iy)
{
}

Computer::Computer(const Computer &rhs)
: _brand(rhs._brand)//浅拷贝
, _price(rhs._price)
{
}

Computer pc1("Huawei Matebook14", 5699);
Computer pc2 = pc1;//拷贝构造函数

//error double free

Computer::Computer(const Computer & rhs)
: _brand(new char[strlen(rhs._brand) + 1]())
, _price(rhs._price)
{
    strcpy(_brand, rhs._brand);
}

void Point::print()
{
    cout << "(" << _ix
    << "," << _iy
    << ")" << endl;
}

Point pt(1, 2);
pt.print(); //(1, 2)
Point pt2(11, 12);
pt2.print(); //(11, 12)

void Point::print(Point *const this)//this指针是一个指针常量
{
    cout << "(" << this->_ix
    << "," << this->_iy
    << ")" << endl;
}

Point pt1(1, 2), pt2(3, 4);
pt1 = pt2;//赋值操作
pt1.operator=(pt2);
pt3 = Point(5, 6);

Point &Point::operator=(const Point &rhs)
{
    _ix = rhs._ix;//此时为赋值，不应该写成初始化形式
    _iy = rhs._iy;
    return *this;
}

Computer &Computer::operator=(const Computer &rhs)
{
    _brand = rhs._brand;
    _price = rhs._price;
    return *this;
}

Computer &Computer::operator=(const Computer &rhs)
{
    strcpy(_brand, rhs._brand);
    _price = rhs._price;
    return *this;
}

Computer &Computer::operator=(const Computer &rhs)
{
    if(this != &rhs) //1、解决自复制问题
    {
        delete [] _brand; //2、释放左操作数
        _brand = nullptr;
        _brand = new char[strlen(rhs._brand) + 1](); //3、深拷贝
        strcpy(_brand, rhs._brand);
        _price = rhs._price;
    }
    return *this;
}