c++笔记

1.using namespace std 告诉编译器使用 std 命名空间。命名空间是 C++ 中一个相对新的概念

2. g++ a.cpp 生成a.out 可以直接 ./a.out执行

3.三字符表

三字符组	替换
??=	#
??/	\
??’	^
??(	[
??)	]
??!	\|
??<	{
??>	}
??-	~

3.1 const

const只修改它右边的类型值
const必须在&左边才是常引用
const引用指向不同类型会生成一个临时变量，也就是达到了常量的作用了，

int hi = 27;
const int &age = hi;

1 2	int hi = 27; const int &age = hi;

struct Person {
    int age;
};


    Person person1 = {27};
    Person person2 = {28};
    
    // 不能改 *rp 也就是*rp的值不能改
    const Person *rP = &person1;
    *rP = person2;  // ❌
    (*rP).age = 29; // ❌
    rP -> age = 30; // ❌
    

   // 不能修改rp的指向
    Person *const rP = &person1;
    rp = &person2; // ❌

struct Person {

int age;

};

Person person1 = {27};

Person person2 = {28};

// 不能改 *rp 也就是*rp的值不能改

const Person *rP = &person1;

*rP = person2; // ❌

(*rP).age = 29; // ❌

rP -> age = 30; // ❌

// 不能修改rp的指向

Person *const rP = &person1;

rp = &person2; // ❌

    int age = 28;
    int b = 33;
    
    // const的*h 直接值不能改, 引用可以修改
    const int *h = &age;
    h = &b; // ✅
    *h = 22; // ❌
    
    // h的引用不可以改, 直接值能改
    int *const h = &age;
    h = &b; // ❌
    *h = 22; // ✅

int age = 28;

int b = 33;

// const的*h 直接值不能改, 引用可以修改

const int *h = &age;

h = &b; // ✅

*h = 22; // ❌

// h的引用不可以改, 直接值能改

int *const h = &age;

h = &b; // ❌

*h = 22; // ✅

4.explicit构造函数是用来防止隐式转换的

class Test1
{
public:
    Test1(int n)
    {
        num=n;
    }
private:
    int num;
};

class Test2
{
public:
    explicit Test2(int n)
    {
        num=n;
    }//explicit(显式)构造函数
private:
    int num;
};

int main()
{
    Test1 t1=12;//隐式调用其构造函数,成功
    Test2 t2=12;//编译错误,不能隐式调用其构造函数
    Test2 t2(12);//显式调用成功
    return 0;
}

class Test1

{

public:

Test1(int n)

{

num=n;

}

private:

int num;

};

class Test2

{

public:

explicit Test2(int n)

{

num=n;

}//explicit(显式)构造函数

private:

int num;

};

int main()

{

Test1 t1=12;//隐式调用其构造函数,成功

Test2 t2=12;//编译错误,不能隐式调用其构造函数

Test2 t2(12);//显式调用成功

return 0;

}

5.std命名空间，假设你不使用预处理 using namespace std;就要加上 std::String . 如果加上了using namespace std，可以直接String

5.0 cin

#include <iostream>
    int age = 10;
    cin >> age;

#include <iostream>

int age = 10;

cin >> age;

5.1 extern “C” 告诉编译器用C语言的方式查找编译，如下

// test.h 
#ifndef Line_h
#define Line_h

#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif
    void testC(int a);
#ifdef __cplusplus
}
#endif


#endif /* Line_h */

// Cline.cpp 可以直接调用
#include "Line.h"

// test.h

#ifndef Line_h

#define Line_h

#include <stdio.h>

#ifdef __cplusplus

extern "C" {

#endif

void testC(int a);

#ifdef __cplusplus

}

#endif

#endif /* Line_h */

// Cline.cpp 可以直接调用

#include "Line.h"

因为c c++最后生成的函数名称并一致，所有要指定用哪种语言去编译。 __cplusplus是在C++中使用，在C的.c中如果不加，是不知道extern “C”这玩意

如果调用Chead 每次都extern太麻烦（如下）

extern "C" {
#include "Line.h"
}

extern "C" {

#include "Line.h"

}

6.lambda ([=]:是将外部所有的变量 copy一份, [&]: 引用外部变量同一地址)

[]：默认不捕获任何变量；
[=]：默认以值捕获所有变量；
[&]：默认以引用捕获所有变量；
[x]：仅以值捕获x，其它变量不捕获；
[&x]：仅以引用捕获x，其它变量不捕获；
[=, &x]：默认以值捕获所有变量，但是x是例外，通过引用捕获；
[&, x]：默认以引用捕获所有变量，但是x是例外，通过值捕获；
[this]：通过引用捕获当前对象（其实是复制指针）；
[*this]：通过传值方式捕获当前对象；

 int age = 26;
 auto labFun = [=](int x, int y) -> int { return age+x+y; };
 int ala = labFun(1,2);
 cout << ala << endl;

int age = 26;

auto labFun = [=](int x, int y) -> int { return age+x+y; };

int ala = labFun(1,2);

cout << ala << endl;

int age = 26;
auto labFun = [&](int x, int y) -> int { return age+x+y; };
age = 27;
int ala = labFun(1,2);
cout << ala << endl;  // 30

int age = 26;

auto labFun = [&](int x, int y) -> int { return age+x+y; };

age = 27;

int ala = labFun(1,2);

cout << ala << endl; // 30

int age = 26;
auto labFun = [=,&age](int x, int y) -> int { return age+x+y; };
age = 27;
int ala = labFun(1,2);
cout << ala << endl; // 30

int age = 26;

auto labFun = [=,&age](int x, int y) -> int { return age+x+y; };

age = 27;

int ala = labFun(1,2);

cout << ala << endl; // 30

捕获this

#include <iostream>
using namespace std;
 
class test
{
public:
    void hello() {
        cout << "test hello!n";
    };
    void lambda() {
        auto fun = [this]{ // 捕获了 this 指针
            this->hello(); // 这里 this 调用的就是 class test 的对象了
        };
        fun();
    }
};
 
int main()
{
    test t;
    t.lambda();
}

#include <iostream>

using namespace std;

class test

{

public:

void hello() {

cout << "test hello!n";

};

void lambda() {

auto fun = [this]{ // 捕获了 this 指针

this->hello(); // 这里 this 调用的就是 class test 的对象了

};

fun();

}

};

int main()

{

test t;

t.lambda();

}

6.1 默认参数

void test(int a,int b=22, int=33);

void test(int a,int b, int c)
{
    cout << "Test() " << a << b << c<< endl;
}

int main(int argc, const char * argv[]) {
    test(1,3);
}

void test(int a,int b=22, int=33);

void test(int a,int b, int c)

{

cout << "Test() " << a << b << c<< endl;

}

int main(int argc, const char * argv[]) {

test(1,3);

}

7.随机数

srand( (unsigned)time(NULL) );
cout << rand() << endl;

1 2	srand( (unsigned)time(NULL) ); cout << rand() << endl;

8.setw格式化输出（空格）

#include <iomanip>
using std::setw;

cout << "Element" << setw( 6 ) << "Value" << endl;

#include <iomanip>

using std::setw;

cout << "Element" << setw( 6 ) << "Value" << endl;

9.strcmp代码实现

int strcmp(const char *str1,const char *str2)
{
    while(*str1 == *str2)
    {
        if(*str1 == '\0')
        {
            return 0;
        }
        
        str1++;
        str2++;
    }
    
    cout << "str1=" << *str1 << " str2=" << *str2 << endl;
    
    return *str1 - *str2;
}

int strcmp(const char *str1,const char *str2)

{

while(*str1 == *str2)

{

if(*str1 == '\0')

{

return 0;

}

str1++;

str2++;

}

cout << "str1=" << *str1 << " str2=" << *str2 << endl;

return *str1 - *str2;

}

10.引用

定义时必须初始化，一旦指向了一个变量，就不可在改（指针的话是可以改的。引用和指针的区别）
可以初始化一个引用引用另一个引用，只是一个别名
不存在引用的引用，不存在引用的指针，不存引用数组（数组里放多个引用是不存在的）

引用和指针的区别？

引用初始化就一个指向后不可改
数组不存在放引用
可作为函数返回值为引用去修改函数内返回值（局部函数变量没有意义）

void quoteSomePoint(int &a, int &b)
{
    a = 11;
    b = 22;
    
    cout<< &a << " :: " << &b<< endl;
}

int main()
{
   int a=10, b=20;
   quoteSomePoint(a,b);
}

void quoteSomePoint(int &a, int &b)

{

a = 11;

b = 22;

cout<< &a << " :: " << &b<< endl;

}

int main()

{

int a=10, b=20;

quoteSomePoint(a,b);

}

数组引用:

int arr[] = {1,3,4,5};
int (&rArr)[4] = arr;

1 2	int arr[] = {1,3,4,5}; int (&rArr)[4] = arr;

10.1 重复引用问题，如多次#include

#ifndef #define #endif受C\C++支持，不收编译器限制
#pragma once （老编译器不支持）
#ifndef #define #endif可以对部分代码， #pragma once对整个文件

11. struck

void printStrBook(Books book)
{
    cout << "2222222" << book.title << "point=" << &book<< endl;
}

 Books book;
 strcpy(book.title, "sdklksd");

void printStrBook(Books book)

{

cout << "2222222" << book.title << "point=" << &book<< endl;

}

Books book;

strcpy(book.title, "sdklksd");

12.函数

#.hpp
class Person
{
public:
    char name[16];
    char address[33];
    
    void didload();
};

#.cpp
void Person::didload()
{
    Person person;
    strcpy(person.name, "张三");
    strcpy(person.address, "北京");

    printf("person.name=%s, person.address=%s",person.name,person.address);
}

#.hpp

class Person

{

public:

char name[16];

char address[33];

void didload();

};

#.cpp

void Person::didload()

{

Person person;

strcpy(person.name, "张三");

strcpy(person.address, "北京");

printf("person.name=%s, person.address=%s",person.name,person.address);

}

:: 叫作用域区分符，指明一个函数属于哪个类或一个数据属于哪个类。
:: 可以不跟类名，表示全局数据或全局函数（即非成员函数）

*构造函数:

#.hpp
class Person
{
public:
    Person();
    Person(int age);
};

#.cpp
/** 构造函数 */
Person::Person(void)
{
    printf("Person 构造函数开始");
}

/** 带参数构造函数*/
Person::Person(int age)
{
    printf("age=%d",age);
}

#.hpp

class Person

{

public:

Person();

Person(int age);

};

#.cpp

/** 构造函数 */

Person::Person(void)

{

printf("Person 构造函数开始");

}

/** 带参数构造函数*/

Person::Person(int age)

{

printf("age=%d",age);

}

#.hpp
class Cat {
public:
    int m_x;
    Cat(int a);
};

#.cpp
Cat::Cat(int a):m_x(a)
{
    printf("cat a=%d,mx=%d",a,m_x);
}

#.hpp

class Cat {

public:

int m_x;

Cat(int a);

};

#.cpp

Cat::Cat(int a):m_x(a)

{

printf("cat a=%d,mx=%d",a,m_x);

}

构造函数调构造函数必须构造函数1：构造函数2

Struct Person{
  int age;
  int height;

  Person():Person(20,28) {
  }

  Person(int age, int height) {
  }
]

Struct Person{

int age;

int height;

Person():Person(20,28) {

}

Person(int age, int height) {

}

]

12.1 虚函数 (实现多态 )

class Person {
    int m_age;
public:
     void run();
    
    // 虚函数用于实现多态， 在类的结构布局中  前8个字节是虚函数表 每个类都有
    virtual void eat();
    
    virtual ~Person();
};
   
class Student : public Person
{
public:
 int age;
 void run();
 void eat();
 
 Student();
 ~Student();
};

// main
Person *stu = new Student();
stu -> eat();  // Student
    
delete stu; // Person

class Person {

int m_age;

public:

void run();

// 虚函数用于实现多态，在类的结构布局中前8个字节是虚函数表每个类都有

virtual void eat();

virtual ~Person();

};

class Student : public Person

{

public:

int age;

void run();

void eat();

Student();

~Student();

};

// main

Person *stu = new Student();

stu -> eat(); // Student

delete stu; // Person

父类用virtual声明为虚函数，子类重写，如果不重写调用父类的函数。这时候如果有虚函数，在类的结构体首地址是8字节的虚函数表专门存放虚函数，如果没有声明虚函数是调用左边编译时的类型，如果delete stu; 这时候析构函数没有声明虚函数所有调用的是Person析构

13.友元 friend

在一个.h中有些函数指定特定的类可以调用，其他类不能调用

友元关系不能传递
友元关系是单向的
友元关系不能被继承

class Cat {
public:
    friend Person;
    
private:
    char name[22]; # name是private，只有在Person中可以调用
};

class Cat {

public:

friend Person;

private:

char name[22]; # name是private，只有在Person中可以调用

};

14. 内联inline函数

内联能提高函数的执行效率，但是他是在调用的时候copy代码导致代码量和内存增加，要慎用！

不可用的情况：

函数代码比较长，导致代码过大
函数内循环或者其他复杂的控制结构，那么执行函数体内代码时间比函数调用开销大多，因此内联意义不大

编译器一般选择短小而简单的函数来内联

现代处理器由于更好的利用了指令缓存, 小巧的代码往往执行更快。

目的是为了解决程序中函数调用的效率问题,解决一些频繁调用的小函数大量消耗栈空间（栈内存）的问题,在系统下，栈空间是有限的，假如频繁大量的使用就会造成因栈空间不足而导致程序出错的问题,并不是说声明了内联就会内联，声明内联只是一个建议而已。

15.static

class Box
{
   public:
      static int objectCount;
}

// 初始化类 Box 的静态成员
int Box::objectCount = 0;
cout << "Total objects: " << Box::objectCount << endl;

class Box

{

public:

static int objectCount;

}

// 初始化类 Box 的静态成员

int Box::objectCount = 0;

cout << "Total objects: " << Box::objectCount << endl;

16.copy构造函数

Line::Line (int len)
{
    printf("构造\n");
    ptr = new int;
    *ptr = len;
}

Line::Line (const Line &obj)
{
    printf("copy构造\n");
    ptr = new int ;
    *ptr = *obj.ptr;
}

Line::~Line()
{
    printf("释放 = %p add=%d \n",this,add);
    delete ptr;
}

Line::Line (int len)

{

printf("构造\n");

ptr = new int;

*ptr = len;

}

Line::Line (const Line &obj)

{

printf("copy构造\n");

ptr = new int ;

*ptr = *obj.ptr;

}

Line::~Line()

{

printf("释放 = %p add=%d \n",this,add);

delete ptr;

}

Line line(9);
Line linea = line; 这一步会调用copy构造函数

17.inline

内联函数的目的是为了解决程序中函数调用的效率问题，这么说吧，程序在编译时，编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换，而对于其他的函数，都是在运行时候才被替代（空间换时间）。

在内联函数内不允许使用循环语句和开关语句
在使用前定义
类中内部定义的函数是内联函数（有些函数即使声明为内联的也不一定会被编译器内联, 这点很重要; 比如虚函数和递归函数就不会被正常内联.）

定义: 当函数被声明为内联函数之后, 编译器会将其内联展开, 而不是按通常的函数调用机制进行调用.

优点: 当函数体比较小的时候, 内联该函数可以令目标代码更加高效. 对于存取函数以及其它函数体比较短, 性能关键的函数, 鼓励使用内联.

缺点: 滥用内联将导致程序变慢. 内联可能使目标代码量或增或减, 这取决于内联函数的大小. 内联非常短小的存取函数通常会减少代码大小, 但内联一个相当大的函数将戏剧性的增加代码大小. 现代处理器由于更好的利用了指令缓存, 小巧的代码往往执行更快

何时使用：1.代码量小 2.调用频率高其中有些函数声明inline也不一定是内联，如递归

inline int  inlineTest(int a, int b)
{
    return a + b;
}

int main(int argc, const char * argv[]) {
   // 如果使用inline 编译器其实会把inlineTest代码copy过来直接去实现，忽略掉函数， 就是直接1+2
    inlineTest(1,2);
    return 0;
}

inline int inlineTest(int a, int b)

{

return a + b;

}

int main(int argc, const char * argv[]) {

// 如果使用inline 编译器其实会把inlineTest代码copy过来直接去实现，忽略掉函数，就是直接1+2

inlineTest(1,2);

return 0;

}

17.1 inline和#define区别？

inline具有语法检测
函数特性。如果int a=10; 在#define sum(a,b) (a) + (b)中调sum(a++)会成 a++ + a++ 就有问题了

18.static

静态变量

class StDor
{
    static int age;
    void run()
    {
        printf("run");
    }
};

int StDor::age = 11;

class StDor

{

static int age;

void run()

{

printf("run");

}

};

int StDor::age = 11;

静态函数

class StDor {
   static int getCount()
      {
         return 11;
      }
}

int main(void)
{
  StDor::getCount();
}

class StDor {

static int getCount()

{

return 11;

}

int main(void)

{

StDor::getCount();

}

19.继承

class cat: public Animal, public other
{
}

class cat: public Animal, public other

{

}

19.1 struct和class区别？

struct默认变量是public， class 变量默认是private

20.重载

double Box::getVolume(void)
{
    return width * height;
}

void Box::setWidth(double w)
{
    width = w;
}

void Box::setHeight(double h)
{
    height = h;
}

// 重载 + 运算符，用于把两个 Box 对象相加
Box Box::operator*(const Box& b)
{
    Box box;
    box.width = this->width + b.width;
    box.height = this->height + b.height;
    return box;
}


// 使用
 Box box1;
 Box box2;
 box1.width = 3;
 box1.height = 4;
 
 box2.width = 5;
 box2.height = 6;
 
 double sum1 = box1.getVolume();
 double sum2 = box2.getVolume();
 
 Box b = box1 * box2;
 
 printf("sum1=%f, sum2=%f, b.width=%f,b.height=%f",sum1,sum2,b.width,b.height);

double Box::getVolume(void)

{

return width * height;

}

void Box::setWidth(double w)

{

width = w;

}

void Box::setHeight(double h)

{

height = h;

}

// 重载 + 运算符，用于把两个 Box 对象相加

Box Box::operator*(const Box& b)

{

Box box;

box.width = this->width + b.width;

box.height = this->height + b.height;

return box;

}

// 使用

Box box1;

Box box2;

box1.width = 3;

box1.height = 4;

box2.width = 5;

box2.height = 6;

double sum1 = box1.getVolume();

double sum2 = box2.getVolume();

Box b = box1 * box2;

printf("sum1=%f, sum2=%f, b.width=%f,b.height=%f",sum1,sum2,b.width,b.height);

双目算术运算符	+ (加)，-(减)，*(乘)，/(除)，% (取模)
关系运算符	==(等于)，!= (不等于)，< (小于)，> (大于>，<=(小于等于)，>=(大于等于)
逻辑运算符	\|\|(逻辑或)，&&(逻辑与)，!(逻辑非)
单目运算符	+ (正)，-(负)，*(指针)，&(取地址)
自增自减运算符	++(自增)，–(自减)
位运算符	\| (按位或)，& (按位与)，~(按位取反)，^(按位异或),，<< (左移)，>>(右移)
赋值运算符	=, +=, -=, *=, /= , % = , &=, \|=, ^=, <<=, >>=
空间申请与释放	new, delete, new[ ] , delete[]
其他运算符	()(函数调用)，->(成员访问)，,(逗号)，[](下标)

不可重载的运算符列表：

.：成员访问运算符
.*, ->*：成员指针访问运算符
::：域运算符
sizeof：长度运算符
?:：条件运算符
#：预处理符号

21.三维数组创建和释放

int ***array;
// 假定数组第一维为 m， 第二维为 n， 第三维为h
// 动态分配空间
array = new int **[m];
for( int i=0; i<m; i++ )
{
    array[i] = new int *[n];
    for( int j=0; j<n; j++ )
    {
        array[i][j] = new int [h];
    }
}
//释放
for( int i=0; i<m; i++ )
{
    for( int j=0; j<n; j++ )
    {
        delete array[i][j];
    }
    delete array[i];
}
delete [] array;

int ***array;

// 假定数组第一维为 m，第二维为 n，第三维为h

// 动态分配空间

array = new int **[m];

for( int i=0; i<m; i++ )

{

array[i] = new int *[n];

for( int j=0; j<n; j++ )

{

array[i][j] = new int [h];

}

//释放

for( int i=0; i<m; i++ )

{

for( int j=0; j<n; j++ )

{

delete array[i][j];

}

delete array[i];

}

delete [] array;

22.数组创建和释放

#include <iostream>
using namespace std;
 
class Box
{
   public:
      Box() { 
         cout << "调用构造函数！" <<endl; 
      }
      ~Box() { 
         cout << "调用析构函数！" <<endl; 
      }
};
 
int main( )
{
   Box* myBoxArray = new Box[4];
 
   delete [] myBoxArray; // 删除数组
   return 0;
}

#include <iostream>

using namespace std;

class Box

{

public:

Box() {

cout << "调用构造函数！" <<endl;

}

~Box() {

cout << "调用析构函数！" <<endl;

}

};

int main( )

{

Box* myBoxArray = new Box[4];

delete [] myBoxArray; // 删除数组

return 0;

}

23.数组的释放

class A
{
    private:
        char *m_cBuffer;
        int m_nLen;
    public:
        A(){ m_cBuffer = new char[m_nLen]; }
        ~A() { delete [] m_cBuffer; }
};
A *a = new A[10];

// 仅释放了a指针指向的全部内存空间 但是只调用了a[0]对象的析构函数 剩下的从a[1]到a[9]这9个用户自行分配的m_cBuffer对应内存空间将不能释放 从而造成内存泄漏
delete a;

// 调用使用类对象的析构函数释放用户自己分配内存空间并且   释放了a指针指向的全部内存空间
delete [] a;

class A

{

private:

char *m_cBuffer;

int m_nLen;

public:

A(){ m_cBuffer = new char[m_nLen]; }

~A() { delete [] m_cBuffer; }

};

A *a = new A[10];

// 仅释放了a指针指向的全部内存空间但是只调用了a[0]对象的析构函数剩下的从a[1]到a[9]这9个用户自行分配的m_cBuffer对应内存空间将不能释放从而造成内存泄漏

delete a;

// 调用使用类对象的析构函数释放用户自己分配内存空间并且释放了a指针指向的全部内存空间

delete [] a;

23.1 malloc(5) 可能是上次的数据，所以用memset(p,0,5); 来清空内存上的数据 // 0：全部是0, 5个字节长度全是0

Person p;
p.age = 27;
p.height = 176;
memset(&p,0,sizeof(p));

Person pr[] = {{1,2,4}, {43,5,6}, {32,5,2}};
memset(pr, 0,sizeof(pr));

Person p;

p.age = 27;

p.height = 176;

memset(&p,0,sizeof(p));

Person pr[] = {{1,2,4}, {43,5,6}, {32,5,2}};

memset(pr, 0,sizeof(pr));

23.2 new

// 并没有初始化，还是上次那数据..
int *p1 = new int;
// 初始化为0
int *p2 = new int();
// 初始化为6
int *p3 = new int(6);

// 没有初始化
int *p4 = new int[6];
// 全部初始化为0
int *p5 = new int[6]();
// 全部初始化为0
int *p6 = new int[6]{};
// 全部初始化为8
int *p7 = new int[6]{8};

// 并没有初始化，还是上次那数据..

int *p1 = new int;

// 初始化为0

int *p2 = new int();

// 初始化为6

int *p3 = new int(6);

// 没有初始化

int *p4 = new int[6];

// 全部初始化为0

int *p5 = new int[6]();

// 全部初始化为0

int *p6 = new int[6]{};

// 全部初始化为8

int *p7 = new int[6]{8};

24.自定义命名空间

namespace FNameSpace {
    void run(void)
    {
        printf("run -------");
    }
}

 FNameSpace::run();

#在别的类中调用用using
using namespace FNameSpace;

namespace FNameSpace {

void run(void)

{

printf("run -------");

}

FNameSpace::run();

#在别的类中调用用using

using namespace FNameSpace;

嵌套命名空间

namespace namespace_name1 {
   // 代码声明
   namespace namespace_name2 {
      // 代码声明
   }
}

#使用
<span class="hl-comment">// 访问 namespace_name2 中的成员
</span> <span class="hl-reserved">using</span> <span class="hl-types">namespace</span> <span class="hl-identifier">namespace_name1</span><span class="hl-code">::</span><span class="hl-identifier">namespace_name2</span><span class="hl-code">; 

</span><span class="hl-comment">// 访问 namespace:name1 中的成员</span> 
<span class="hl-reserved">using</span> <span class="hl-types">namespace</span> <span class="hl-identifier">namespace_name1</span><span class="hl-code">;</span>

namespace namespace_name1 {

// 代码声明

namespace namespace_name2 {

// 代码声明

}

#使用

// 访问 namespace_name2 中的成员

using namespace namespace_name1::namespace_name2;

// 访问 namespace:name1 中的成员

using namespace namespace_name1;

25.泛型

template <typename T>
inline T const& Max (T const& a, T const& b)
{
    return a < b ? b:a;
}

template <typename T>

inline T const& Max (T const& a, T const& b)

{

return a < b ? b:a;

}

26.预处理宏 #define是替换 gcc -E hello.cpp > hello

#define MKSTR( x ) #x
MKSTR(文集)
#define CONCAT( x, y )  x ## y
count << CONCAT(a,b); 相当于cout << ab

#define MKSTR( x ) #x

MKSTR(文集)

#define CONCAT( x, y ) x ## y

count << CONCAT(a,b); 相当于cout << ab

问题：

1.这个指针地址和fn不一致， ins[] 形参做了什么？？

2.2.delete[] arr; 在后面使用会有什么问题？如何避免？

delete是释放了对一块内存的使用权，但可能被别的使用并修改或者被回收，（释放后arr指针依然存在的，还是指向那个未知内存）如果delete后在使用可能会造成野指针，或者结果改变。 delete后最好把指针指向NULL，不用管那块内存什么情况，在后面使用是判断是否为NULL来处理（delete后不应该再使用了，可能有复杂情况下）（和操作系统也有一定关系，何时回收）

3.如果自由存储区已被用完，可能无法成功分配内存。所以建议检查 new 运算符是否返回 NULL 指针（new 与 malloc() 函数相比，其主要的优点是，new 不只是分配了内存，它还创建了对象。）

double* pvalue  = NULL;
if( !(pvalue  = new double ))
{
   cout << "Error: out of memory." <<endl;
   exit(1);
 
}

double* pvalue = NULL;

if( !(pvalue = new double ))

{

cout << "Error: out of memory." <<endl;

exit(1);

}

4.new malloc区别?

new是分配内存并创建对象（走默认的构造函数），malloc只是在堆上分内存要强制转换成对象（不走默认的构造函数）

 // 用malloc()函数在堆区分配一块内存空间，然后用强制类型转换将该块内存空间
    // 解释为是一个TEST类对象，这不会调用TEST的默认构造函数
    TEST * pObj1 = (TEST *)malloc(sizeof(TEST));
    pObj1->Print();

    // 用new在堆区创建一个TEST类的对象，这会调用TEST类的默认构造函数
    TEST * pObj2 = new TEST;
    pObj2->Print();

// 用malloc()函数在堆区分配一块内存空间，然后用强制类型转换将该块内存空间

// 解释为是一个TEST类对象，这不会调用TEST的默认构造函数

TEST * pObj1 = (TEST *)malloc(sizeof(TEST));

pObj1->Print();

// 用new在堆区创建一个TEST类的对象，这会调用TEST类的默认构造函数

TEST * pObj2 = new TEST;

pObj2->Print();

发表回复 取消回复

发表回复取消回复