blocks|key|1756588|text|编辑:我想我误解了你的问题。据我所知，在这段代码中没有一致性问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1756589|我是从脑子里想出来的，但它应该是正确的：|1756590|static+int+lastIndex+=+0;
static+char+**registeredNames+=+new+char*[numberOfNames];

void+RegisterName(const+*+char+const+name)
{
++++bool+found+=+false;
++++//loop+to+see+if+name+already+registered+snipped
++++for+(int+i+=+0;+i+<+lastIndex;+i%2B%2B)
++++{
++++++++if+(strcmp(name,+registeredNames[i]+==+0))
++++++++{
++++++++++++found+=+true;
++++++++++++break;
++++++++}
++++}

++++if+(!found)
++++{
++++++++registeredNames[lastIndex%2B%2B]+=+name;
++++}
}|code-block|syntax|javascript|1756591|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Edit: I guess I misunderstood your question. There is no constness problem in this code I'm aware of.

I'm doing this from my head but it should be about right:

<pre><code>static int lastIndex = 0;
static char **registeredNames = new char*[numberOfNames];

void RegisterName(const * char const name)
{
 bool found = false;
 //loop to see if name already registered snipped
 for (int i = 0; i &lt; lastIndex; i++)
 {
 if (strcmp(name, registeredNames[i] == 0))
 {
 found = true;
 break;
 }
 }

 if (!found)
 {
 registeredNames[lastIndex++] = name;
 }
}
</code></pre>

blocks|key|1756638|text|您可能需要使用strcmp来查看字符串是否已经存储：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1756639|for+(int+index=0;+index<=lastIndex;+index%2B%2B)
{
++if+(strcmp(registeredNames[index],+name)+==+0)
++{
++++return;+//+Already+registered
++}
}|code-block|syntax|javascript|1756640|然后，如果您确实需要存储字符串的副本，则需要分配一个缓冲区并复制字符。|1756641|char*+nameCopy+=+malloc(length%2B1);
strcpy(nameCopy,+name);
registeredNames[lastIndex%2B%2B]+=+nameCopy;|1756642|您没有提到您的输入是否以NULL结尾-如果不是，则需要格外小心，并且strcmp/strcpy将不适用。|1756643|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You'll probably need to use strcmp to see if the string is already stored:

<pre><code>for (int index=0; index&lt;=lastIndex; index++)
{
 if (strcmp(registeredNames[index], name) == 0)
 {
 return; // Already registered
 }
}
</code></pre>

Then if you really need to store a copy of the string, then you'll need to allocate a buffer and copy the characters over.

<pre><code>char* nameCopy = malloc(length+1);
strcpy(nameCopy, name);
registeredNames[lastIndex++] = nameCopy;
</code></pre>

You didn't mention whether your input is NULL terminated - if not, then extra care is needed, and strcmp/strcpy won't be suitable.

blocks|key|1541788|text|使用char*需要您使用C函数。在您的例子中，您真正需要的是复制字符串。为了帮助您，您可以使用strndup函数。然后你必须写一些类似这样的东西：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1541789|void+RegisterName(const+char*+name)
{
++//+loop+to+see+if+name+already+registered+snipped
++if(notFound)
++{
++++registerNames[lastIndex%2B%2B]+=+stdndup(name,+MAX_STRING_LENGTH);
++}
}|code-block|syntax|javascript|1541790|这段代码假设你的数组足够大。|1541791|当然，最好的方法是正确地实现您自己的字符串、数组和列表……或者说服你的老板STL不再是邪恶的了！|1541792|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Working with char* requires you to work with C functions. In your case, what you really need is to copy the strings around. To help you, you have the strndup function. Then you'll have to write something like:

<pre><code>void RegisterName(const char* name)
{
 // loop to see if name already registered snipped
 if(notFound)
 {
 registerNames[lastIndex++] = stdndup(name, MAX_STRING_LENGTH);
 }
}
</code></pre>

This code suppose your array is big enough.

Of course, the very best would be to properly implement your own string and array and list, ... or to convince your boss the STL is not evil anymore !

blocks|key|1756762|text|使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1756763|const+char+**registeredNames+=+new+const+char+*+[numberOfNames];|code-block|syntax|javascript|1756764|将允许您将const+*+char+const分配给数组的元素。|offset|length|style|CODE|1756765|出于好奇，为什么“工作要求任何最方便的C%2B%2B构造都不能使用”？|1756766|entityMap^0|0|0|5|I|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Using:

<pre><code>const char **registeredNames = new const char * [numberOfNames];
</code></pre>

will allow you to assign a <code>const * char const</code> to an element of the array.

Just out of curiosity, why does "work mandates that none of the most handy C++ constructs can be used"?

blocks|key|1756816|text|为什么你不能使用STL呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1756817|无论如何，我建议您实现一个简单的string类并列出您自己的模板。这样，您就可以像往常一样使用相同的技术，并将指针和内存管理限制在这些类中。如果你模仿STL，那就更好了。|1756818|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Why can't you use the STL?

Anyway, I would suggest that you implement a simple string class and list templates of your own. That way you can use the same techniques as you normally would and keep the pointer and memory management confined to those classes. If you mimic the STL, it would be even better.

blocks|key|1756857|text|如果可移植性是个问题，您可能需要查看STLport。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1756858|entityMap|0|LINK|mutability|MUTABLE|url|http://www.stlport.org/^0|I|7|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

If portability is an issue, you may want to check out <a href="http://www.stlport.org/" rel="nofollow noreferrer">STLport</a>.

blocks|key|1541981|text|如果你真的不能使用stl+(我后悔我在游戏行业的时候相信这是真的)，那么你就不能创建你自己的string类吗？最基本的string类将在构造和赋值时分配内存，并在析构函数中处理删除。稍后，您可以根据需要添加更多功能。完全可移植，并且非常容易编写和单元测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1541982|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If you really can't use stl (and I regret believing that was true when I was in the games industry) then can you not create your own string class? The most basic of string class would allocate memory on construction and assignment, and handle the delete in the destructor. Later you could add further functionality as you need it. Totally portable, and very easy to write and unit test.

blocks|key|1542046|text|我能理解为什么你不能使用STL+--大多数人都会让你的代码膨胀得很厉害。然而，游戏程序员也有针对游戏程序员的实现--+RDESTL就是这样一个库。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1542047|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/p/rdestl/^0|1N|6|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I can understand why you can't use STL - most do bloat your code terribly. However there are implementations for games programmers by games programmers - <a href="http://code.google.com/p/rdestl/" rel="nofollow noreferrer">RDESTL</a> is one such library.

blocks|key|1542159|text|可以避免使用STL是有正当理由的。当在内存或速度非常重要的固定环境中工作时，使用STL有时很难知道幕后发生了什么。是的，你可以编写自己的内存分配器，是的，速度通常不是问题，但跨平台的STL实现之间存在差异，这些差异可能是微妙的和潜在的but。在考虑使用内存时，内存可能是我最关心的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1542160|内存是宝贵的，我们如何使用它需要严格控制。除非你曾经走过这条路，否则这个概念可能没有意义，但它是真的。我们确实允许在工具中使用STL+(在游戏代码之外)，但在实际游戏中是被禁止的。另一个相关的问题是代码大小。我不太确定STL对可执行文件的大小有多大的贡献，但我们已经看到使用STL时代码大小的显著增加。即使你的可执行文件“只”大了2M，你的游戏的其他东西的RAM也减少了2M。|1542161|STL当然很好。但它可能会被不知道自己在做什么的程序员滥用。这不是故意的，但当你不想看到它们时，它会带来令人不快的惊喜(同样，内存膨胀和性能问题)|1542162|我相信你已经接近你的解决方案了。|1542163|for+(+i+=+0;+i+<+lastIndex;+i%2B%2B+)+{
++++if+(+!strcmp(&registeredNames[i],+name+)+{
++++++++break;++++//+name+was+found
++++}
}
if+(+i+==+lastIndex+)+{
++++//+name+was+not+found+in+the+registeredNames+list
++++registeredNames[lastIndex%2B%2B]+=+strdup(name);
}|code-block|syntax|javascript|1542164|您可能不想使用strdup。这只是一个如何存储给定示例的名称的示例。您可能希望确保自己不想为新名称分配空间，或者使用应用程序中可能已有的其他内存结构。|1542165|请不要写字符串类。我曾经举过string类作为如何不在C%2B%2B中重新设计基本C结构的最糟糕的例子。是的，string类可以对你隐藏许多漂亮的细节，但它的内存使用模式很糟糕，而且不适合控制台(例如ps3或360等)环境。大约8年前，我们做了同样的事情。200000%2B内存分配在我们进入主菜单之前。内存非常零散，我们无法让游戏的其余部分适应固定的环境。我们最终把它拆掉了。|1542166|类设计在某些方面很棒，但这不是其中之一。这只是一个观点，但它是基于现实世界的经验。|1542167|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|X|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

There are legitimate reasons that STL might be avoided. When working in fixed environments where memory or speed is a premium, it's sometimes difficult to tell what is going on under the hood with STL. Yes, you can write your own memory allocators, and yes, speed generally isn't a problem, but there are differences between STL implementations across platforms, and those differences mighe be subtle and potentially buggy. Memory is perhaps my biggest concern when thinking about using it.

Memory is precious, and how we use it needs to be tightly controlled. Unless you've been down this road, this concept might not make sense, but it's true. We do allow for STL usage in tools (outside of game code), but it's prohibited inside of the actual game. One other related problem is code size. I am slightly unsure of how much STL can contribute to executable size, but we've seen marked increases in code size when using STL. Even if your executable is "only" 2M bigger, that's 2M less RAM for something else for your game.

STL is nice for sure. But it can be abused by programmers who don't know what they are doing. It's not intentional, but it can provide nasty surprises when you don't want to see them (again, memory bloat and performance issues)

I'm sure that you are close with your solution.

<pre><code>for ( i = 0; i &lt; lastIndex; i++ ) {
 if ( !strcmp(&amp;registeredNames[i], name ) {
 break; // name was found
 }
}
if ( i == lastIndex ) {
 // name was not found in the registeredNames list
 registeredNames[lastIndex++] = strdup(name);
}
</code></pre>

You might not want to use strdup. That's simply an example of how to to store the name given your example. You might want to make sure that you either don't want to allocate space for the new name yourself, or use some other memory construct that might already be available in your app.

And please, don't write a string class. I have held up string classes as perhaps the worst example of how not to re-engineer a basic C construct in C++. Yes, the string class can hide lots of nifty details from you, but it's memory usage patterns are terrible, and those don't fit well into a console (i.e. ps3 or 360, etc) environment. About 8 years ago we did the same time. 200000+ memory allocations before we hit the main menu. Memory was terribly fragmented and we couldn't get the rest of the game to fit in the fixed environment. We wound up ripping it out.

Class design is great for some things, but this isn't one of them. This is an opinion, but it's based on real world experience.

blocks|key|1542242|text|如果您不担心约定，只想完成工作，请使用realloc。我一直在为列表做这样的事情，大概是这样的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1542243|T**+list+=+0;
unsigned+int+length+=+0;

T*+AddItem(T+Item)
{
+list+=+realloc(list,+sizeof(T)*(length%2B1));
+if(!list)+return+0;
+list[length]+=+new+T(Item);
+%2B%2Blength;
+return+list[length];
}

void+CleanupList()
{
+for(unsigned+int+i+=+0;+i+<+length;+%2B%2Bi)
+{
++delete+item[i];
+}
+free(list)
}|code-block|syntax|javascript|1542244|你还可以做更多的事情，例如，每次列表大小加倍时只使用realloc，通过索引或检查相等性从列表中删除项的函数，创建一个处理列表的模板类等。(我有一个我很久以前写的，总是用我自己……但遗憾的是，我正在工作，不能只是在这里复制粘贴)。不过，老实说，这可能不会超过STL的等价物，尽管如果您做了大量的工作或STL的实现特别糟糕，它的性能可能与它相当。|1542245|令人恼火的是，C%2B%2B没有运算符更新/调整大小来取代realloc，这将是非常有用的。|1542246|哦，如果我的代码错误百出，我很抱歉，我只是从内存中取出它。|1542247|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you are not worried about conventions and just want to get the job done use realloc. I do this sort of thing for lists all of the time, it goes something like this:

<pre><code>T** list = 0;
unsigned int length = 0;

T* AddItem(T Item)
{
 list = realloc(list, sizeof(T)*(length+1));
 if(!list) return 0;
 list[length] = new T(Item);
 ++length;
 return list[length];
}

void CleanupList()
{
 for(unsigned int i = 0; i &lt; length; ++i)
 {
 delete item[i];
 }
 free(list)
}
</code></pre>

There is more you can do, e.g. only realloc each time the list size doubles, functions for removing items from list by index or by checking equality, make a template class for handling lists etc... (I have one I wrote ages ago and always use myself... but sadly I am at work and can't just copy-paste it here). To be perfectly honest though, this will probably not outperform the STL equivalent, although it may equal its performance if you do a ton of work or have an especially poor implementation of STL.

Annoyingly C++ is without an operator renew/resize to replace realloc, which would be very useful.

Oh, and apologies if my code is error ridden, I just pulled it out from memory.

blocks|key|1757206|text|所有建议的方法都是有效的，我的观点是，如果C#做它的方式是吸引人的，复制它，创建你自己的类/接口来表示相同的抽象，即一个简单的链表类，方法包含和添加，使用其他答案提供的示例代码这应该是相对简单的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1757207|C%2B%2B最棒的一件事是，如果另一种语言有一个很好的实现，你通常可以重现它，你可以让它看起来和行为都像你想要的那样。|1757208|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

All the approaches suggested are valid, my point is if the way C# does it is appealing replicate it, create your own classes/interfaces to present the same abstraction, i.e. a simple linked list class with methods Contains and Add, using the sample code provided by other answers this should be relatively simple.

One of the great things about C++ is generally you can make it look and act the way you want, if another language has a great implementation of something you can usually reproduce it.

blocks|key|1757241|text|常量正确性仍然是常量正确性，无论您是否使用STL。我相信您正在寻找的是使registeredNames成为一个const+char+**，以便对registeredNames[i]+(这是一个const+char+*)的赋值工作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1757242|此外，这真的是你想要做的吗？似乎制作字符串的副本可能更合适。|1757243|此外，考虑到您正在对其执行的操作，您不应该考虑将其存储在列表中，集合会更好。|1757244|entityMap^0|1J|D|20|I|2O|C|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|T|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|K|$]]

const correctness is still const correctness regardless of whether you use the STL or not. I believe what you are looking for is to make registeredNames a <code>const char **</code> so that the assignment to <code>registeredNames[i]</code> (which is a <code>const char *</code>) works.

Moreover, is this really what you want to be doing? It seems like making a copy of the string is probably more appropriate.

Moreover still, you shouldn't be thinking about storing this in a list given the operation you are doing on it, a set would be better.

blocks|key|1542353|text|我已经使用这个String类很多年了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1542354|http://www.robertnz.net/string.htm|offset|length|1542355|它几乎提供了STL字符串的所有功能，但它是作为一个真正的类而不是模板实现的，并且不使用STL。|1542356|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|Y|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

I have used this String class for years.

<a href="http://www.robertnz.net/string.htm" rel="nofollow noreferrer" title="String class">http://www.robertnz.net/string.htm</a>

It provides practically all the features of the
STL string but is implemented as a true class not a template
and does not use STL.

I've not used C++ very much in the past, and have recently been doing a lot of C#, and I'm really struggling to get back into the basics of C++ again. This is particularly tricky as work mandates that none of the most handy C++ constructs can be used, so all strings must be char *'s, and there is no provision for STL lists.

What I'm currently trying to do is to create a list of strings, something which would take me no time at all using STL or in C#. Basically I want to have a function such as:

<pre><code>char **registeredNames = new char*[numberOfNames];
</code></pre>

Then,

<pre><code>RegisterName(const * char const name, const int length)
{
 //loop to see if name already registered snipped
 if(notFound)
 {
 registeredNames[lastIndex++] = name;
 }

}
</code></pre>

or, if it was C#...

<pre><code>if(!registeredNames.Contains(name))
{
 registeredNames.Add(name);
}
</code></pre>

and I realize that it doesn't work. I know the const nature of the passed variables (a const pointer and a const string) makes it rather difficult, but my basic problem is that I've always avoided this situation in the past by using STL lists etc. so I've never had to work around it!

C++ strings without <string> and STL

单元测试

内存管理

我过去不太使用C++，最近做了很多C#，我真的很难再回到C++的基础上来。这是特别棘手的，因为工作要求不能使用任何最方便的C++构造，因此所有字符串都必须是char *，并且没有提供STL列表。我现在要做的就是创建一个字符串列表，使用STL或者C#来做这件事不会花费我任何时间。基本上，我想要有一个函数，例如：char ...

问不带<string>和STL的C++字符串
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问不带<string>和STL的C++字符串EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问不带<string>和STL的C++字符串
EN