技术小记5(C++)

最新推荐文章于 2024-09-27 17:57:19 发布

pud_zha

最新推荐文章于 2024-09-27 17:57:19 发布

阅读量388

点赞数

分类专栏：技术杂谈文章标签： c++ iostream class delete c

本文链接：https://blog.csdn.net/pud_zha/article/details/8004630

版权

技术杂谈专栏收录该内容

121 篇文章 0 订阅

订阅专栏

1.Add( int * value );
Add( const int * value );

两个函数不一样

2.vector加入对象时，调用copy assignment，且形参为const,然后调用 operator=()赋值函数（形参可以是const,也可以不是）

3.纯虚函数必须在子类中重新声明，但它还是可以在基类中有自己的实现

4.char *p = "hello"; (int)p输出与printf("%p");是一致的

打印成员函数地址时，必须用printf("%p"),不能用std::cout,因为iostream识别不了CXX::memfun的类型，把它转成了一个bool

5.静态变量，静态函数只有是public时才能独立于对象之外直接存取。

6.在虚函数内部调用另一个虚函数时，可以直接用CXX::memFunction();，可以提高效率

7.class CA
{
private:
const static int m_ca;
//也可以直接 const static int m_ca = 10;
public:
static void Display() //静态函数不能加类型限定符，如const, volatile, virtual
{
std::cout << "CA: " << m_ca << std::endl;
}
};

8.虚函数可以返回不同类型，但仅限于有继承成关系的类的指针或引用

placement new上分配的内存必须直接调用析构函数，系统不会自动调用析构函数
placement new获得的指针如果不是operator new上获得的，就不能delete,否则出错
使用placement new可以使new 分配的对象数组逐个设置初始值

10.nothrow 须包含头文件<new.h>

11.之所以对一般函数，通过类得指针调用的函数只会是本类的函数，而不会是基类或其他函数，其原因就在于这种函数就静态绑定的
与此对应，虚函数就是动态绑定

12.函数的默认参数也是静态绑定，定义一个指针是静态绑定，指向一个对象是动态绑定

13.私有继承的子类不能转为基类

14.取类成员函数地址

C++ class中有三种成员函数,static,nonstatic,virtual

各种成员函数的指针各有区别，以下是一个完整的例子：

class A

{

public:

static void staticmember(){cout<<"static"<<endl;} //static member

void nonstatic(){cout<<"nonstatic"<<endl;} //nonstatic member

virtual void virtualmember(){cout<<"virtual"<<endl;};//virtual member

};

int _tmain(int argc, _TCHAR* argv[])

{

A a;

//static member,取得的是该函数在内存中的实际地址，而且因为static成员是全局的，所以不能用A::限定符

void (*ptrstatic)() = &A::staticmember;

//nonstatic member 取得的是该函数在内存中的实际地址

void (A::*ptrnonstatic)() = &A::nonstatic;

//虚函数取得的是虚函数表中的偏移值，这样可以保证能过指针调用时同样的多态效果

void (A::*ptrvirtual)() = &A::virtualmember;

//函数指针的使用

ptrstatic();

(a.*ptrnonstatic)();

(a.*ptrvirtual)();

}

// build_independ.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <windows.h>

class CT
{
public:
CT()
{}

void Display()
{
std::cout << "CT::Display()" << std::endl;
}

public:
static void Display2(int value)
{
std::cout << "CT::Display2() " << value << std::endl;
}

virtual void Display3(const char* ptr)
{
m_value = 3;
std::cout << "CT::Display3() " << ptr << std::endl;
}

private:
int m_value;
};

class CD : public CT
{
public:
virtual void Display3(const char* ptr)
{
std::cout << "CD::Display3() " << ptr << std::endl;
}
};

void (CT::*fun)();
void (*fun2)(int);
void (CT::*fun3)(const char*);

int _tmain(int argc, _TCHAR* argv[])
{
CT t;
fun = CT::Display;
(t.*fun)();

fun2 = CT::Display2;
fun2(12);

CD d;
fun3 = CT::Display3;
(d.*fun3)("hello");

printf("%pn", CT::Display);
printf("%p\n", CT::Display2);
printf("%p\n", CT::Display3);
}

note:
C++ reminds us of that by disallowing the conversion from pointer to member of Drived Class to pointer to member of BaseClass.(member, 类的成员变量）
类的方法没有“虚拟”属性
there is a predefined conversion from a pointer to a member function of a base class to a pointer to a member function of a derived class, not the reverse
This makes sense if you consider that a base class member function will attempt to access only base class members through its this pointer whereas a derived class function may attempt to access members that are not present in the base class.

普通函数指针：
Note that both the argument and return types contribute to the type of a function or function pointer.
char *(*fp4)(int,int);
char *(*fp5)(short,short) = 0;
fp4 = fp5; // error! type mismatch