关于c语言中new的使用

Posted 2023-04-30

#include<stdio.h>
int main ()

int score[][4]=59,60,78,23,78,65,63,54,89,83,88,90;
int * seach(int(*pi)[4]);
int * p;
int i,j;
for(i=0;i<3;i++)

p=seach(score+i);
if(p==*(score+i))

printf("--------\n");
for(j=0;j<4;j++)

printf("%d ",*(p+j));

printf("\n");


return 0;

int * seach(int(*pi)[4])

int i=0;
int *pt;
pt=NULL;
for(;i<4;i++)

if(*(* pi+i)<60)
pt=*pi;

return (pt);

"int *pt;"这个是不是要写成"int *pt=new int;"
int *pt这个应该是局部指针变量我看书上说要用到new操作符来分配个持久空间。可在未使用new字符之前编译器并未报错或者出现乱码。 向高手请教······

必须使用malloc函数,因为C语言没有new这个操作符,但是如果你的编译器是C++的话,是可以使用new的。

所以程序就是:

long *pNumber = (long*)malloc(sizeof(long) * 1000000);

开辟后就可以像数组一样使用它了，使用完后,一定要记得释放它,用free,像这样free(pNumber);使用new更方便。

代码:

long* pNumber = new long[1000000];

使用完后,使用delete[]

像delete[] pNumnber;

扩展资料：

总结C++中三种关于"new"的使用方法

其一是new operator，也叫new表达式；其二是operator new，也叫new操作符。这两个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如：

string* ps = new string("abc");

上面这个new表达式完成了两件事情：申请内存和初始化对象。

new操作符类似于C语言中的malloc，只是负责申请内存，例如：void* buffer = operator new(sizeof(string));

注意这里多了一个operator。这是new的第二个用法，算比较常见。

第三个用法不常见，它用于在给定的内存中初始化对象，也就是说你手中已有一块闲置的内存，例如：

void* buffer = operator new(sizeof(string));

//那么现在buffer是你所拥有闲置内存的指针

buffer = new(buffer) string("abc"); //调用了placement new，在buffer所指向的内存中初始化string类型的对象，初始值是"abc"

事实上，placement new也是new表达式的一种，但是比普通的new表达式多了一个参数，当然完成的操作和返回值也不同。

因此上面new的第一种用法可以分解两个动作，分别为后面的两种用法。

与new对应的delete没有三种语法，它只有两种，分别是delete operator和operator delete，也称为delete表达式和delete操作符。delete表达式和new表达式对应，完成对象的析构和内存的释放操作。而delete操作符只是用于内存的释放，和C语言中的free相似。例如：

string* ps = new string("abc");

...

delete ps; //调用delete表达式，先析构再释放

void* buffer = operator new(sizeof(string));

...

operator delete(buffer); //释放

placement new是在指定位置初始化对象，也就是调用了构造函数，因此与之对应的就是析构函数了，只不过它不叫placement　delete而已。

void *pv = operator new(sizeof(vector<int>));

pv = new(pv) vector<int>(8, 0);

...

static_cast<vector<int>* >(pv)->~vector(); // call destruct function

operator delete(pv); // free memory

pv = NULL;

参考技术A 在C语言中 我们必须使用malloc函数,因为C语言没有new这个操作符,但是如果你的编译器是C++的话,是可以使用new的.

C语言的malloc函数的使用方法:
1.首先定义一个long指针,像这样long* pNumber;
2.动态开辟一片内存(1000000个long),可以这样malloc(sizeof(long) * 1000000); malloc函数唯一的参数是一个size_t(unsigned long类型),它表示你要开辟的内存的大小,我们要开辟1000000个long.
3.返回一个void*指针,我们必须转换成long*指针,像这样(long*)malloc(..);

所以你要的程序就是:
long *pNumber = (long*)malloc(sizeof(long) * 1000000);
开辟后就可以像数组一样使用它了
使用完后,一定要记得释放它,用free,像这样free(pNumber);

使用new更方便
代码:
long* pNumber = new long[1000000];
使用完后,使用delete[]
像delete[] pNumnber;
本回答被提问者和网友采纳 参考技术B C语言申请空间的不是用new ，而是malloc。
C++才有new可以用。
你说的那个应该写成
int * pt = malloc ( sizeof (int) )

关于C/C++的一些问题，着急找高手求助

请高手帮我回答一下这7个问题，非常着急，回答满7题者才给分，工作面视急需：
1.new和malloc有什么区别？
2.inline函数有什么特点和优点？
3.堆和栈有什么区别？
4.static函数和变量有什么特点？
5.“extern C”有什么意义？
6.C语言的关键字volatile的含义？
7.assert有什么作用？

NEW是C++的关键字，能进行类型的检查之类的

malloc是C跟C++都可以用的
不能进行类型检查之类

如果是在C++中，推荐使用new

inline函数区别与普通函数在于调用普通函数时程序有压栈和出栈操作，而inline（内联）函数编译器在预处理的时候会把它的代码加到调用它的函数中，而不用额外的跳转操作，从而提高了程序的效率。
但是inline不允许有switch, 循环等复杂语句。

堆，可用NEW对它分配内存，DELETE销毁内存空间。
栈，是由程序本身建立，分配，消除的内存空间！他服从先进后出(FILO)的原则，从而可以把各个变量按生存期分开！

static 声明的变量在C语言中有两方面的特征：
1)、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。
2)、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。
Tips:
A.若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；
B.若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；
C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题；
D.如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static变量(这样的函数被称为：带“内部存储器”功能的的函数)
E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。

函数前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件(所以又称内部函数)。使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。

扩展分析:术语static有着不寻常的历史.起初，在C中引入关键字static是为了表示退出一个块后仍然存在的局部变量。随后，static在C中有了第二种含义：用来表示不能被其它文件访问的全局变量和函数。为了避免引入新的关键字，所以仍使用static关键字来表示这第二种含义。最后，C++重用了这个关键字，并赋予它与前面不同的第三种含义：表示属于一个类而不是属于此类的任何特定对象的变量和函数(与Java中此关键字的含义相同)。

全局变量、静态全局变量、静态局部变量和局部变量的区别变量可以分为：全局变量、静态全局变量、静态局部变量和局部变量。
按存储区域分，全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域，局部变量存放在内存的栈区。
按作用域分，全局变量在整个工程文件内都有效；静态全局变量只在定义它的文件内有效；静态局部变量只在定义它的函数内有效，只是程序仅分配一次内存，函数返回后，该变量不会消失；局部变量在定义它的函数内有效，但是函数返回后失效。全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用， 因此可以避免在其它源文件中引起错误。
从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围。

static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件

static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;
static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；
static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝
全局变量和静态变量如果没有手工初始化，则由编译器初始化为0。局部变量的值不可知。

C++中extern “C”含义深层探索
1.引言
C++语言的创建初衷是“a better C”，但是这并不意味着C++中类似C 语言的全局变量
和函数所采用的编译和链接方式与C 语言完全相同。作为一种欲与C 兼容的语言，C++保留了
一部分过程式语言的特点，因而它可以定义不属于任何类的全局变量和函数。但是，C++毕竟
是一种面向对象的程序设计语言，为了支持函数的重载，C++对全局函数的处理方式与C 有明
显的不同。
2.从标准头文件说起
某企业曾经给出如下的一道面试题：
面试题
为什么标准头文件都有类似以下的结构？
#ifndef _TEST_H
#define _TEST_H
#ifdef __cplusplus
extern "C"
#endif
/*...*/
#ifdef __cplusplus

#endif
#endif /* _TEST_H */
分析
显然，头文件中的编译宏“#ifndef _TEST_H、#define _TEST_H、#endif” 的作用是防止
该头文件被重复引用。
那么
#ifdef __cplusplus
extern "C"
#endif
#ifdef __cplusplus

#endif
的作用又是什么呢？
3.深层揭密extern "C"
extern "C" 包含双重含义，从字面上即可得到：首先，被它修饰的目标是“extern”的；
其次，被它修饰的目标是“C”的。让我们来详细解读这两重含义。
被extern "C"限定的函数或变量是extern 类型的；
extern 是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告
诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。记住，下列语句：
extern int a;
仅仅是一个变量的声明，其并不是在定义变量a，并未为a 分配内存空间(特别注意：实
际上现在一般的编译器都会对上述语句作声明处理，但链接器在链接过程中如果没有发现该
变量的定义，一般会在第一次遇到该变量声明的地方，自动定义)。变量a 在所有模块中作为
一种全局变量只能被定义一次，否则会出现连接错误。
通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字
extern 声明。例如，如果模块B 欲引用该模块A 中定义的全局变量和函数时只需包含模块A
的头文件即可。这样，模块B 中调用模块A 中的函数时，在编译阶段，模块B 虽然找不到该
函数，但是并不会报错；它会在连接阶段中从模块A 编译生成的目标代码中找到此函数。
与extern 对应的关键字是static，被它修饰的全局变量和函数只能在本模块中使用。因
此，一个函数或变量只可能被本模块使用时，其不可能被extern “C”修饰。
被extern "C"修饰的变量和函数是按照C 语言方式编译和连接的；
未加extern “C”声明时的编译方式
首先看看C++中对类似C 的函数是怎样编译的。
作为一种面向对象的语言，C++支持函数重载，而过程式语言C 则不支持。函数被C++编
译后在符号库中的名字与C 语言的不同。例如，假设某个函数的原型为：
void foo( int x, int y );
该函数被C 编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像
_foo_int_int 之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，
生成的新名字称为“mangled name”）。
_foo_int_int 这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制
来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float
y )编译生成的符号是不相同的，后者为_foo_int_float。
同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的
类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函
数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全
局变量名字不同。
未加extern "C"声明时的连接方式
假设在C++中，模块A 的头文件如下：
// 模块A 头文件 moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
int foo( int x, int y );
#endif
在模块B 中引用该函数：
// 模块B 实现文件 moduleB.cpp
＃i nclude "moduleA.h"
foo(2,3);
实际上，在连接阶段，连接器会从模块A 生成的目标文件moduleA.obj 中寻找
_foo_int_int 这样的符号！
加extern "C"声明后的编译和连接方式
加extern "C"声明后，模块A 的头文件变为：
// 模块A 头文件 moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
extern "C" int foo( int x, int y );
#endif
在模块B 的实现文件中仍然调用foo( 2,3 )，其结果是：
（1）模块A 编译生成foo 的目标代码时，没有对其名字进行特殊处理，采用了C 语言的
方式；
（2）连接器在为模块B 的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。
如果在模块A 中函数声明了foo 为extern "C"类型，而模块B 中包含的是extern int
foo( int x, int y ) ，则模块B 找不到模块A 中的函数；反之亦然。
所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特
性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留
在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入
地理解许多问题）：
实现C++与C 及其它语言的混合编程。
明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的使用技巧。
4.extern "C"的惯用法
（1）在C++中引用C 语言中的函数和变量，在包含C 语言头文件（假设为cExample.h）
时，需进行下列处理：
extern "C"

＃i nclude "cExample.h"

而在C 语言的头文件中，对其外部函数只能指定为extern 类型，C 语言中不支持extern
"C"声明，在.c 文件中包含了extern "C"时会出现编译语法错误。
笔者编写的C++引用C 函数例子工程中包含的三个文件的源代码如下：
/* c 语言头文件：cExample.h */
#ifndef C_EXAMPLE_H
#define C_EXAMPLE_H
extern int add(int x,int y);
#endif
/* c 语言实现文件：cExample.c */
＃i nclude "cExample.h"
int add( int x, int y )

return x + y;

// c++实现文件，调用add：cppFile.cpp
extern "C"

＃i nclude "cExample.h"

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

add(2,3);
return 0;

如果C++调用一个C 语言编写的.DLL 时，当包括.DLL 的头文件或声明接口函数时，应加
extern "C" 。
（2）在C 中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C
语言中不能直接引用声明了extern "C"的该头文件，应该仅将C 文件中将C++中定义的extern
"C"函数声明为extern 类型。
笔者编写的C 引用C++函数例子工程中包含的三个文件的源代码如下：
//C++头文件 cppExample.h
#ifndef CPP_EXAMPLE_H
#define CPP_EXAMPLE_H
extern "C" int add( int x, int y );
#endif
//C++实现文件 cppExample.cpp
＃i nclude "cppExample.h"
int add( int x, int y )

return x + y;

/* C 实现文件 cFile.c
/* 这样会编译出错：＃i nclude "cExample.h" */
extern int add( int x, int y );
int main( int argc, char* argv[] )

add( 2, 3 );
return 0;

如果深入理解了第3 节中所阐述的extern "C"在编译和连接阶段发挥的作用，就能真正
理解本节所阐述的从C++引用C 函数和C 引用C++函数的惯用法。对第4 节给出的示例代码，
需要特别留意各个细节。

volatile 影响编译器编译的结果,指出，volatile 变量是随时可能发生变化的，与volatile变量有关的运算，不要进行编译优化，以免出错，（VC++ 在产生release版可执行码时会进行编译优化，加volatile关键字的变量有关的运算，将不进行编译优化。）。

例如：
volatile int i=10;
int j = i;
...
int k = i;

volatile 告诉编译器i是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，因而编译器生成的可执行码会重新从i的地址读取数据放在k中。

而优化做法是，由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读的数据放在k中。而不是重新从i里面读。这样以来，如果i是一个寄存器变量或者表示一个端口数据就容易出错，所以说volatile可以保证对特殊地址的稳定访问，不会出错。

断言(assert)是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true。如果表达式计算为 false，那么系统会报告一个 Assertionerror。它用于调试目的：
assert(a > 0); // throws an Assertionerror if a <= 0
断言可以有两种形式：
assert Expression1 ;
assert Expression1 : Expression2 ;
Expression1 应该总是产生一个布尔值。
Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。
断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：
javac -source 1.4 Test.java
要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。
要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。
要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。
可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。 参考技术A 上面的那么长篇大论,面试时有那么多时间去回答吗,别人一听就知道从哪里抄来的而不是自己理解的.不容易过关.

1. malloc与new都是用来申请空间用的,但在C++中却很少用malloc去申请空间.因为malloc只负责给对象指针分配空间，而不去调用构造函数和对其初始化.C++中一个类的对象构造，是需要分配空间的，调用构造函数以及对其初始化.

2. 由于函数内数据的内存空间是有限的,如果频繁大量的使用函数就会造成空间不足所造成的程序出错的问题,而使用inline就避免了频繁调用函数对栈内存重复开辟所带来的消耗.

3. 堆，可用NEW对它分配内存，DELETE销毁内存空间。
栈，是由程序本身建立，分配，消除的内存空间！他服从先进后出(FILO)的原则，从而可以把各个变量按生存期分开！

4. Static函数在调用时不会加上this指针,所以它是属于整个类的,而不对应于某一个实例对象.用它可以操纵静态变量,但不能控制非静态的成员变量
Static变量可以在没有对象的时候存在,并且所有对象都共享该变量.而其它变量必须要有对象存在时才存在,而且每当创建一个对象的时候就从改变量处
复制一份.

5. 主要用于动态链接库，使得导出函数名称与C语言规则一致（不改变），方便不同的编译器甚至是不同的开发语言调用。

6. volatile定义是这样的: 用该类型定义的变量意味着没有具体的赋值也会改变,是为了提示系统,防止意外用的. 例如,某一个指针赋值了系统的时钟程序入口,其值即使没有在程序中改变,也会随时变化,而用了volatile定义,系统就会提前注意到这个. 综合两点作用:防错,优化.

7. 一个判断宏.如果不符合条件会给出一个错误码提示.且只在debug状态下有用.这样你用release时就不会出现多余的代码了。 参考技术B 发下我的观点，补充下楼上的第一和第二点，其他的基本同意，分给他吧：

1.new和malloc有什么区别？

new除了开辟所给类型所需要的内存空间以外，同时还调用该类型的构造函数进行构造，而malloc则只有分配内存这一个动作，不会调用构造函数。

2.inline函数有什么特点和优点？

补充：不是不允许，只要你愿意，你在inline函数里写什么都可以，只是如果inline函数的代码量过大的话，就违背了inline函数出现的初衷以及使用它的原则。

inline函数是为比较短小的，而又被频繁使用的过程所服务的，以此来减少函数调用时跳转指令和保存寄存器内容（比如esp等）的开销，以前人们喜欢用宏来实现这个功能，但宏有其本质上的缺点，比如无类型检查等。

如果inline函数代码过多的话，不仅体现不了inline函数的优化效果，而且还会造成程序代码的膨胀，得不偿失啊呵呵。

所以inline函数里原则上不应该有循环、跳转或开关语句等。 参考技术C 哎呀,如果我是你的面试的主考官,那么我不得不对你说,真的很遗憾!
如果你这些都不懂,你还去找这样的工作?!
建议你还去看看C++ PRIMER!