相同函数的C const/non-const版本
在C语言中，函数的const和non-const版本主要用于处理不同的参数类型和使用场景。以下是对这两种版本的详细解释：
- Const版本：
const版本的函数主要用于处理const类型的参数，即不可修改的参数。这种版本的函数可以保证在处理参数时不会意外地修改参数的值。const版本的函数声明如下：
return_type function_name(const parameter_type *parameter_name);例如，如果我们有一个名为printArray的函数，用于打印整数数组，我们可以为其创建一个const版本：
void printArray(const int *arr, int size) {
for (int i = 0; i< size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}- Non-const版本：
non-const版本的函数主要用于处理可修改的参数。这种版本的函数可以在处理参数时修改参数的值。non-const版本的函数声明如下：
return_type function_name(parameter_type *parameter_name);例如，如果我们有一个名为sortArray的函数，用于对整数数组进行排序，我们可以为其创建一个non-const版本：
void sortArray(int *arr, int size) {
for (int i = 0; i< size - 1; i++) {
for (int j = 0; j< size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}总结：
- Const版本的函数用于处理const类型的参数，保证不会意外修改参数的值。
- Non-const版本的函数用于处理可修改的参数，可以在处理参数时修改参数的值。
- 在实际编程中，根据需要选择合适的函数版本，以确保代码的安全性和可维护性。
相关·内容
为什么将Foo和Bar的函数参数从const更改为non-const会导致不同的编译器错误？
或者换句话说:为什么Foo(false)确定，而Bar(false)则导致编译器错误？
#include <string>
void Foo(const std::string &test)
{
}
void Bar(std::string &test)
{
}
int main(int , char* [])
{
Foo(false);
Bar(false); // error C2664: 'Bar' : cannot conver
浏览 5提问于2014-07-24得票数 3
回答已采纳
在回答时，我发现了一个有趣的差异，即成员运算符和非成员运算符之间对引用的重载解析。
给定两个非成员运算符，一个作为常量传递左参数，另一个作为非常数传递，当使用右值调用时，GCC 4.4.3和MSVC2010都选择常量版本。
但是，给定两个成员运算符，一个常量和一个非常量，两个编译器都会选择非常量版本。
我假设两个编译器都遵守这方面的标准，所以我很好奇为什么常量重载解析在成员和非成员之间存在差异。请多多指教:)
下面是一些代码来说明不同之处：
#include <iostream>
class C {
public:
C(int i) { }
/*
C o
浏览 1提问于2012-01-03得票数 3
回答已采纳
2回答
c++如何引用返回向量？
、、、、
我是一名c++学生，在理解和完成作业的这一部分时需要一些帮助。
我有一个SalesItem对象的向量：
class Invoice
{
public:
//blabla
vector<SalesItem> *getSalesItems(); //code provided by the assignment.
private:
{
//blabla
vector<SalesItem> salesItems;
};
我需要将该向量作为引用返回：
void Invoice::getSalesItems() //error on this li
浏览 2提问于2014-04-23得票数 5
2回答
我有以下c++11代码：
#include <iostream>
#include <type_traits>
template<typename T> void overload(T&& t);
template<> void overload<char&>(char& t) { std::cout << "char& called" << std::endl; }
template<> void overload<const cha
浏览 1提问于2013-06-27得票数 3
回答已采纳
1回答
使用ref-限定符的过载解决方案
、、、、
在处理ref限定的函数重载时，我得到了与GCC (4.8.1)和Clang (2.9和主干)不同的结果。考虑以下代码：
#include <iostream>
#include <utility>
struct foo
{
int& bar() &
{
std::cout << "non-const lvalue" << std::endl;
return _bar;
}
//~ int&& bar() &&
浏览 0提问于2013-06-16得票数 25
回答已采纳
6回答
给定以下代码片段，
class Base
{
public:
virtual void eval() const
{
std::cout<<"Base Const Eval\n";
}
};
class Derived:public Base
{
public:
void eval()
{
std::cout<<"Derived Non-Const Eval\n";
}
};
int main()
{
Derived d;
Base* p
浏览 0提问于2010-09-30得票数 6
回答已采纳
5回答
函数模板返回类型推导
、、、
我有一些带有const和一些泛型类型Node的非constgetter的C类 template <typename NodeType>
class CParent{};
class Node {};
class C : public CParent<Node> {
Node& getNode(Index i);
const Node& getNode(Index i) const;
}; 现在，我想为C类的对象创建一个调用getNode的别名函数 template <class CType>
NodeType
浏览 32提问于2017-01-02得票数 11
回答已采纳
我对C++相当陌生，并试图理解我正在查看的一些代码：
bool ClassName::ClassMethod(const STRUCT_THING* const parameterName) {}
争论的第二个“康斯特”的目的是什么？它和const STRUCT_THING* parameterName有什么区别？
谢谢!
浏览 2提问于2014-10-14得票数 3
回答已采纳
这是在c++中，使用VisualStudio2019(还没有尝试其他编译器)。我想添加一个模板化的operator=方法。如果参数是非const的，它可以正常工作。但是如果参数是const，即使我用const参数制作了一个版本，也不会调用它。相反，它只做一个简单的浅拷贝。
如果我使用一个命名函数而不是操作符，它就会像预期的那样工作。类似地，如果没有模板化，则按预期调用运算符。组合似乎就是问题所在。
这里有一个例子，展示了这个问题。
class CTest
{
public:
int x{};
CTest() = default;
CTest(int value) :
浏览 3提问于2020-04-03得票数 0
回答已采纳
2回答
const成员函数指针的专门化
、、、、
我试图对const成员函数的一些实用程序代码进行专门化，但是在获得一个简单的测试用例上有问题。
为了简化工作，我使用了Boost.FunctionTypes和它的模板--一个MPL序列，它应该为const成员函数标记。
但是使用下面的测试代码，const成员函数的专门化就失败了。有人知道怎么做吗？
测试代码输出(使用VC8和boost 1.40)：
非连续
非连续
预期产出如下：
非连续
康斯特
测试代码本身：
#include <iostream>
#include <boost/function.hpp>
#include <boost/bind.hpp>
浏览 3提问于2009-12-13得票数 4
回答已采纳
我有一个代码库，其中对于Matrix类，对于()运算符有以下两个定义：
template <class T> T& Matrix<T>::operator() (unsigned row, unsigned col)
{
......
}
template <class T> T Matrix<T>::operator() (unsigned row, unsigned col) const
{
......
}
我理解的一件事是，第二个声明没有返回引用，但是第二个声明中的const是什么意思呢？还有，当我说mat(i
浏览 0提问于2010-03-30得票数 3
回答已采纳
1回答
从C++11开始，可以有两个复制构造函数，一个接受T&类型的参数，另一个接受const T&类型的参数。
我遇到这样一种情况：(表面上)添加了第二个副本构造函数，当构造函数在派生类中继承时，它们都不会被调用。当副本构造函数都存在时，将被模板化构造函数覆盖。
这是一个MWE：
struct A {
template <typename... Args>
A (Args&&... args)
{ std::cout << "non-default ctor called\n"; }
A (A&) {
浏览 0提问于2018-07-04得票数 3
回答已采纳
我正在尝试把windows的MFC类移植到linux上，因为我必须把windows软件移植到linux上。
下面是我需要移植的代码
165: SMapCI it = _s$.find("nchairs");
166: if (it==_s$.end()) return 10;
167: int n = strtoul(it->second.text.GetString(), NULL, 10);
_s$和SMapCI的定义如下
typedef std::map<CString, STablemapSymbol> SMap;
SMap _s$;
浏览 2提问于2012-08-24得票数 0
回答已采纳
2回答
简化的示例代码：
#include <iostream>
template<typename T>
void func(T &x)
{
std::cout << "non-const " << x << std::endl;
}
template<typename T>
void func(const T &x)
{
std::cout << "const " << x << std::endl;
}
template
浏览 0提问于2012-04-20得票数 16
回答已采纳
4回答
String::~String() { std::cout<<"String()" <<std::endl; }
我想知道这个析构函数的实现是否有效？和另一个关于const成员函数限定符的问题，我知道const函数不能更改该类中的变量，它只是只读的。如果没有其他奇怪的问题，我想我可以理解，但我看到了以下几个问题：
- It allows the invocation of a non-const member function for the object pointed to by this
- It guarantees that only
浏览 6提问于2011-05-06得票数 3
3回答
我正在学习C++，我读到:如果一个数据成员被声明为可变的，那么从一个const成员函数为这个数据成员指定一个值是合法的。，但是下面的代码编译时没有gcc的任何错误或警告。(这不是一个真实的代码示例，我只是编写它来测试可变关键字)
class M
{
public:
M(){x=10;};
int getX() {x++; return x;};
private:
mutable int x;
};
int main()
{
M xx;
std::cout << xx.getX() << std::endl;
}
我不应该宣布getX为const吗？
浏览 3提问于2013-04-25得票数 1
回答已采纳
请考虑以下示例：
#include <new>
struct FunctionObject
{
int operator()() // non-const, modifies the state of this object
{
i += 1;
j += 2;
return i + j;
}
int i = 0;
int j = 0;
};
struct Wrapper
{
explicit Wrapper(const FunctionObject& input_objec
浏览 7提问于2020-10-20得票数 8
回答已采纳
修改以前的const值的只有在原始变量为const时才是未定义的。
..。
如果您使用它来删除对没有用const声明的内容的引用，那么它是安全的。
..。
例如，当重载基于的成员函数时，这是非常有用的。它还可用于向对象添加const，例如调用成员函数重载。
我无法理解上述引语的含义。我要求你们给我举例说明这些引语是什么意思。
浏览 4提问于2020-08-28得票数 0
回答已采纳
文摘
我很少有C/C++技能。我主要是用Java学习编程，所以我选择了C++ (以C++11为目标)作为学习更好的语言。在我当前的C++项目中，我必须使用折扣 C库来实现它的标记功能。
简单地解释一下我的代码:成员变量std::string markdown_是我想要“编译”到HTML的标记。要做到这一点，我必须使用以下折扣函数：
MMIOT *mkd_string(char *string, int size, int flags);
int mkd_compile(MMIOT *document, int flags);
int mkd_document(MMIOT *document,
浏览 0提问于2013-10-16得票数 8
回答已采纳
2回答
如果其中一个成员函数被声明为const，则函数重载可能发生在具有相同参数数的两个成员函数之间。
但是，如果一个函数有一个const参数，另一个函数有相同类型的非const参数怎么办？它对引用和指针有用吗？如果C++提供了它，为什么它会提供？如果你知道的话，请告诉我原因。
下面是帮助您理解上述场景的示例。
void fun(const int i)
{
cout << "fun(const int) called ";
}
void fun(int i)
{
cout << "fun(int ) called " ;
}
i
浏览 1提问于2012-10-02得票数 14
我在const结构中重载了non-const和c++函数。然后，我运行了这个程序，我想知道，它运行得很好，没有模糊的错误。
#include <iostream>
struct St
{
int f() const
{
return 1;
}
int f()
{
return 2;
}
} s;
int main()
{
int ret = s.f();
std::cout<<ret<<std::endl;
return 0;
}
所以，我只想知道，为什么编译器不给
浏览 2提问于2017-10-05得票数 6
回答已采纳
据我所知，C++只具有基于参数的函数重载或关联对象参数。但是我发现向量有两个operator[]。它将在以下代码中选择正确的函数：
std::vector<int> v;
v[0] = 1; // This will select the non-const version.
return &v[0]; // This will select the const version.
有人能解释一下这是怎么发生的吗？
reference operator[] (size_type n);
const_reference operator[] (size_type n
浏览 4提问于2015-11-02得票数 0
回答已采纳
如果我有以下条件：
class A {
int foo() const {
j++;
return i;
}
int& foo() {
return i;
}
int i;
mutable int j;
};
很明显像这样的东西
A a;
a.foo() = 5;
调用非常量版本。但需要满足哪些条件才能确保调用是对常量或非常量版本的调用，举几个例子……
int i = a.foo(); //I would expect to call the const. Is it guaranteed?
浏览 0提问于2011-04-08得票数 3
回答已采纳
从函数返回指向非const的指针(该指针是通过修改指向const的(非const)指针获得的)的最佳实践是什么？如下所示：
NODE *top_level(const NODE *input)
{
while (input->parent != nullptr)
input = input->parent; // NODE::parent is (non-const) NODE*
return input; // Compile failure:
// Cannot convert from 'const NODE
浏览 0提问于2013-02-06得票数 0
回答已采纳
在以下代码中(摘自effective C++ )：
class A
{
....
char& operator[](std::size_t position) // now just calls const op[]
{
return
const_cast<char&>( // cast away const on op[]'s return type;
static_cast<const TextBlock&>(*this) // add cons
浏览 0提问于2010-09-27得票数 4
我们有一个更大的应用程序，它依赖char和const数组的模板重载。在gcc 7.5，clang，和视觉工作室，下面的代码打印“非CONST”的所有情况。但是，gcc 8.1及以后的产出如下：
#include <iostream>
class MyClass
{
public:
template <size_t N>
MyClass(const char (&value)[N])
{
std::cout << "CONST " << value << '\n&
浏览 4提问于2020-01-27得票数 8
回答已采纳
看看这段代码。测试结构有一个auto_ptr和显式析构函数。当我在Windows环境(VisualStudio2017专业版)中生成错误级别为4()的时，它将显示此警告。
warning C4239: nonstandard extension used: 'argument': conversion from 'Test' to 'Test &' note: A non-const reference may only be bound to an lvalue; copy constructor takes a reference t
浏览 0提问于2017-05-26得票数 3
回答已采纳
3回答
可能重复：
大家好，
在使用类方法和变量时，我经常出错。例如，有时我使用
const int myfunc(const int &obj) const { }
还有一些时候，我觉得结束时不需要const，因为参数已经是const了，所以我不明白为什么要在末尾附加一个const来强制执行这个事实。
浏览 8提问于2011-03-17得票数 0
回答已采纳
2回答
我想在我目前正在做的一个几何学项目中用本征来做线性代数。它是一个很大的图书馆，相对较小，而且易于使用，而且很受欢迎。
但是，我也希望使用自定义的"Double“类来比较计算机精度中的两个浮点值(类似于两者之间的差异必须小于给定的精度)。对于我的自定义类型，我已经实现了大部分std：：c++11函数和所有运算符(包括一元-、conj、imag、abs2.)。我做了这些链接中列出的所有事情：
但是，我仍然会在Eigen Jacobi.h文件中得到编译错误，更具体地说，在第340,341行中，这些错误是：
x[i] = c * xi + numext::conj(s) * yi;
y[
浏览 3提问于2013-11-15得票数 1
回答已采纳
3回答
在C++中，我有时会看到下面这样的声明：
return_type function_name( datatype parameter1, datatype parameter2 ) const
{ /*................*/}
这个常量类型限定符exact在这种情况下做了什么？
浏览 0提问于2010-08-13得票数 11
回答已采纳
片段1:
#include<iostream>
using namespace std;
class C{
public:
C(){}
C(const C& c){
cout<<"const copy constructor called"<<endl;
}
};
int main(){
C c1;
C c2 = c1;
return 0;
}
output：const复制构造函数
片段2：
#include<iostream>
using namespa
浏览 1提问于2016-02-22得票数 5
回答已采纳
下面的代码给了我一个编译错误，但我不知道我做错了什么。很抱歉问了这么愚蠢的问题。
$ cat swapcstrings.cc
#include <iostream>
void swap(char*& c, char*& d) {
char* temp = c;
c = d;
d = temp;
}
int main() {
char c[] = "abcdef";
char d[] = "ghijkl";
std::cout << "[" <<
浏览 0提问于2012-10-08得票数 1
回答已采纳
我有一个类，它包含一个偶尔需要重新计算的数据成员，尽管在需要重新计算之前，它可能会被访问多次。我已经为数据定义了常量和非常量getter方法，并且在getter方法中，我希望检查是否需要运行计算，如果需要，则调用适当的方法。在非常量getter中，我检查值是否是最新的，如果不是，则在返回数据之前运行计算。在const getter中执行相同的操作会导致编译器报告this对象是const类型，而计算方法是非const类型。因此，如果我简单地调用const getter中的非常数getter，代码就会编译，这让我很惊讶。有人能解释一下为什么这样做吗，因为我有点困惑。
class A {
bool
浏览 1提问于2019-07-26得票数 1
3回答
我有一个用户用来与系统接口的类。这个类使用Pimpl隐藏其内部，因此它唯一的实际成员是对执行所有工作的真实隐藏对象的引用。
因为类具有引用语义，所以它通常通过值传递，就像指针一样。这导致了const正确性的问题。只需将一个const值复制到一个非const值中，就可以很容易地打破类的const性质。避免这种情况的唯一办法就是完全防止抄袭。
我希望能够返回这些值的const值，这保留了对象的const性质。而不是创建一个新的类什么的。
基本上，我想阻止它发挥作用：
struct Ref
{
int &t;
Ref(int &_t) : t(_t) {}
};
R
浏览 5提问于2013-06-13得票数 0
回答已采纳
3回答
我在使用模板成员重载操作符并使用make_pair时遇到了一些问题：
class MyArchive
{
public:
template <class C> MyArchive & operator<< (C & c)
{
return (*this);
}
};
class A
{
};
int main()
{
MyArchive oa;
A a;
oa << a; //it works
oa << std::make_pair(std
浏览 5提问于2011-02-16得票数 2
回答已采纳
2回答
在我正在研究的书中，它说，如果我把一个向量传递给一个函数，这个向量的名字总是被看作一个指针。事实上是这样的。但我不明白为什么在第一个函数中编译器允许使用const子句，而在第二个函数中(在第二个函数中，我使用指针搜索元素之间的最大值) no。在函数中，我只想防止向量的修改。
#include <stdio.h>
int find_largest(const int a[], int n);
int find_largest_with_pointer(const int *vettore, int n);
int main(void) {
int my_number[]
浏览 6提问于2019-10-30得票数 2
回答已采纳
当我将函数作为参数传递给c++中的其他函数时，是否必须将其指定为
void callOtherFunctions(void f());
或
void callOtherFunctions(void (*f)());
我不知道引擎盖下会发生什么，所以我试着用下面的简单程序运行这两个版本，替换第二次运行所需的部分。
#include <iostream>
using namespace std;
void printHello();
void callOtherFunctions(void f());
int main() {
callOtherFunctions(pri
浏览 0提问于2015-02-22得票数 1
回答已采纳
我正在尝试用C++为我正在编写的游戏实现一个接口，但我在一个错误中运行。
下面是我创建的接口及其子类：
//Attack.h
//defines a set of values associated with all attacks
//and an interface for all attacks
typedef unsigned const int attack_type;
typedef unsigned const int p_attack_type;
//defines the attack types
static const attack_type NORMAL = 0;
st
浏览 3提问于2012-07-22得票数 7
回答已采纳
下面的代码调用一个传递对成员的引用的const方法，然后修改该成员。
#include <iostream>
struct A {
int i;
A(int _x) : i(_x) { }
void calc(int& j, const int value) const { j = value; }
void set1() { calc(i, 1); }
};
int main()
{
A a(3);
std::cout << a.i << std::endl;
a.set1();
std::cout <&l
浏览 0提问于2018-06-13得票数 5
回答已采纳
假设我有
class A final {
int& ir;
public:
A(int& x) : ir(x) { }
void set(int y) { ir = y; } // non-const method!
int get() const { return ir; }
};
和
const int i;
显然我不能
A a(i);
因为这会破坏常态。但我也不能
const A a(i);
尽管事实是这不会破坏事实上的一致性。C++不支持"const-only“的ctor，例如本例中需要const int&的cto
浏览 8提问于2016-04-21得票数 0
我使用简单的2D数组，但是在我的复制构造函数中我遇到了一个问题。下面是我代码的摘录：
//default constructor
Matrix::Matrix(int r, int c)
{
rows = r;
cols = c;
mainArray = new int[rows*cols];
array = new int *[rows];
for (int i = 0; i < rows; i++)
array[i] = mainArray + (i*cols);
}
//at member
int& Matrix::a
浏览 3提问于2015-04-09得票数 1
回答已采纳
我是C++的新手，这听起来可能很基本。编译器总是查看为我返回const像素值的方法，我不希望它返回bc --我想要更改返回像素的值。这种情况不会在我以前的作业中发生，但这次会发生。有什么办法解决这个问题吗？非常感谢。
提供巴布亚新几内亚课程：
const HSLAPixel & getPixel(unsigned int x, unsigned int y) const;
HSLAPixel & getPixel(unsigned int x, unsigned int y);
我的代码：
HSLAPixel & original = png_.getPixel((*i
浏览 5提问于2022-03-15得票数 -1
1回答
常量构造函数
、、
是否有可能在C++中实现只允许创建const对象的构造函数？
我正在考虑用const和非const方法为接口创建一个装饰器类。从const基对象初始化装饰器应该只能产生常量装饰器，但是从非常量初始化应该产生全功能的装饰器。
struct A
{
virtual void foo(); // requires non-const A
virtual void bar() const; // const method
};
class decorator : public A
{
private:
std::shared_ptr<A> p_
浏览 0提问于2015-05-13得票数 3
我意识到，当您执行const auto_ptr<X> ptr = variable时，仍然能够修改auto_ptr指向的变量的内容。对于原始指针const X * ptr = variable，const阻止您修改它。
那么，让const站在auto_ptr面前的确切目的是什么呢？
浏览 0提问于2016-06-20得票数 3
回答已采纳
1回答
假设我有这个示例模板：
template<class T>
class Wrapper
{
virtual T* ReturnPtr() = 0;
};
然后我继承了它：
class Buffer; //some class
class BufferWrapper : public Wrapper<Buffer>
{
virtual Buffer* ReturnPtr(); //<< (1.)
}
这是正确的方法吗？当我这样编写它时，它不会给我任何intellisense错误，但是一旦我在某个地方编写了ReturnPtr()，它就会告诉我“对象具有与成员
浏览 0提问于2013-02-10得票数 0
回答已采纳
1回答
我构造了以下我的问题的最小示例：
#include <iostream>
struct Foo {
Foo() {
std::cout << "default" << std::endl;
}
Foo(Foo& f2) {
std::cout << "non-const" << std::endl;
}
Foo(const Foo& f2) {
std::cout << "const" << std::
浏览 9提问于2020-06-01得票数 8
回答已采纳
我是通过参考的方式学习的，下面是我所做的测试：
#include <iostream>
using namespace std;
int i = 0;
//If this is uncommented, compiler gives ambiguous definition error.
//void paramCheck (string s) {
// cout << ++i << ". Param is var.\n";
//}
void paramCheck (const string& s) {
cout &
浏览 6提问于2013-07-31得票数 11
回答已采纳
我正在学习C++，学习范奉献德和Josuttis的C++模板的第18章。我重新键入了它们的表达式模板代码，但下面是生成错误的结果
sarray1.cpp:36:6: error: ‘T& SArray<T>::operator[](size_t) const’ cannot be overloaded
T& operator[] (size_t idx) const {
^
sarray1.cpp:32:5: error: with ‘T SArray<T>::operator[](size_t) const’
T operato
浏览 6提问于2015-07-27得票数 2
回答已采纳
2回答
假设String类中有两个重载的成员函数(一个常量版本和一个非常量版本)：
char & String::operator[](int i) //Version 1
{
cout<<"char & String::operator[](int i) get invoked."<<std::endl;
return str[i];
}
const char & String::operator[](int i) const //Version 2
{
cout<<
浏览 0提问于2012-04-21得票数 5
回答已采纳
void testMethod(){
cout<<"Normal Method";
}
void testMethod() const{
cout<<"Const Method";
}
其中哪些将通过调用testMethod()来调用？当我尝试的时候，第一个被调用了。但这是如何决定的，它不可能总是第一个，否则将这两个函数视为不同的函数是没有意义的。
浏览 3提问于2013-05-27得票数 2
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
