有人可以帮助我将我的C ++代码转换为java。我非常困惑，我完全错了。 [英] Can someone help me convert my C++ code to java. Im extremely confused and am running it completely wrong.
问题描述
这是我的c ++
#include < span class =code-keyword>< iostream >
使用 命名空间标准;
int c = 0 ，cost = 999 ;
int 图[ 4 ] [ 4 ] = {{ 0 ， 10 ， 15 ， 20 }，
{ 10 ， 0 ， 35 ， 25 }，
{ 15 ， 35 ， 0 ， 30 }，
{ 20 ， 25 ，< span class =code-digit> 30 ， 0 }
};
void swap（ int * x， int * y）
{
int temp;
temp = * x;
* x = * y;
* y = temp;
}
void copy_array（ int * a， int n）
{
int i，sum = 0 ;
for （i = 0 ; i< = n; i ++）
{
sum + = graph [a [i％ 4 ]] [a [（i + 1 ）％ 4 ]];
}
如果（费用>总和）
{
cost = sum;
}
}
void permute（ int * a，< span class =code-keyword> int i， int n）
{
int j，k;
if （i == n）
{
copy_array（a，n）;
}
else
{
for （j = i; j< = n; j ++）
{
swap（（a + i），（a + j））;
permute（a，i + 1 ，n）;
swap（（a + i），（a + j））;
}
}
}
int main（）
{
int i，j;
int a [] = { 0 ， 1 ， 2 ， 3 };
permute（a， 0 ， 3 ）;
cout<< 最低费用：<<<<<< endl ;
getch（）;
}
我的尝试：
我试图通过在我的主类中创建子类来转换它，但我正在学习C，所以将它带到Java真的让我很烦恼
这是原始问题
作业4 - 电子邮件，分发和继承
从下面选择一个选项。所有（两个）选项都值得相同的点数。为那些发现基本的太容易并且想要更多挑战的学生提供了更高级的选项。确保您已阅读并理解
●本周A和B模块，以及
●模块2R - 实验室作业要求
提交前这项任务。
选项A（基本）。消息，电子邮件和Shweet了解类和问题每条消息都包含一些内容（英国人即将到来。英国人即将来临！和创作者或作者（保罗·里维尔）。我们可以通过添加其他特征来增强这些内容（创建日期和/或时间），但让我们保持简单，并说这些是基本消息的两个方面。
但是，有些消息还有其他组件可以定义它们。例如，一封电子邮件包含一条普通邮件，另外还有至少两个其他项目.a来自电子邮件地址和电子邮件地址。电子邮件是一条消息，但却是一种特殊的消息。所以我们可以闻到附近的遗产。好像它会成为一个很好的基类，而且一个与消息有关系的电子邮件，是派生类或基类消息扩展的一个很好的候选者。
同时，一条推文包括一个普通的消息，加上至少一个其他项目。来自用户ID。一条推文也是一条消息。它有与电子邮件不同的专业化，因此它是基类的不同扩展。 （我们不考虑直接推文，这也需要用户ID。）
不仅电子邮件和推文都包含额外的数据而不是基类消息，但至少在一个实例中我们会看到相同的成员（内容）在派生类中的限制比在基类中有不同的限制（你可以在阅读之前猜出我的建议吗？）。因此，即使我们将推文内容存储在基类成员中，而不需要推文的新内容区域，我们仍然会对该消息内容的长度进行不同的验证。警告。因为这样做是有意义的，我们将命名消息内容消息和消息类Message。所以我在上一段中所谓的内容将在下一步中被称为（小写）消息。该类本身将是（大写）消息。你会看到的。请继续阅读。
文件结构。我更喜欢整个程序的一个文件，因此您可以将所有类与main（）放在一个文件中。
基类：消息您的基类名为Message。公共或受保护（您的选择）静态类常量定义一组完整的限制
和默认值
，如MAX_MSG_LENGTH和DEFAULT_AUTHOR，用于最小，最大长度和默认数据每个成员。将最大消息长度设置为大数（至少一百万），将最大作者长度设置为合理值，如40或65，而不是5或200.
私有成员数据●字符串消息; ●字符串作者;公共方法●默认和2参数构造函数。
●每个成员的Mutator和Accessor。
●一个toString（）方法，为潜在的屏幕提供格式良好的返回字符串I / O.
私有方法●私有静态验证助手，用于过滤客户端参数。这些将支持您的公共方法。
推荐测试o。类消息实例化两个或多个Message对象，一些使用默认构造函数，另一些使用参数获取构造函数。改变一个或多个成员，然后使用toString（）来辅助屏幕输出，这样我们就可以看到所有对象包含的内容。接下来，测试一个或多个访问器。最后，测试两个或更多个mutator，提供合法和非法的参数并测试返回值（从而证明mutator做正确的事）。这是从我的测试中运行的示例（但您必须想象/推断我使用的源并为您的测试创建自己的源，这将产生不同的输出）。
示例测试运行消息类/ * ---------------------------------------------- ----------
基类测试***************************** ******
作者：Kinnard留言---------------------
有些消息不值得发送。
作者：loceff消息---------------- -----
你好世界
测试消息访问者：
Kinnard
你好世界
测试消息变换器：
太长（按预期）
作者：Kinnard消息-------- -------------
有些消息不值得发送。
可接受的长度（应该是。）
作者：Kinnard留言---------------------
LONG STRING abcde abcde abcde abcd 。 abcde abcde abcd。 A B C D。 A B C D。 A B C D。 abc
d。 abcde abcd。 abcde abcde abcde
--------------------------------------- ------------------ * /
派生类：电子邮件您的第一个派生类名为电子邮件。电子邮件使用已存在于基类中的两个成员。电子邮件的消息是基类的消息，基类的作者是电子邮件作者的实际名称（不是我将在下面介绍的电子邮件地址）。不要试图将电子邮件的邮件正文或作者存储为派生类的新成员，否则您将得到-20分 - 您或我不可取。在派生类中复制基类数据意味着你不理解继承是什么，因此这种错误的重要性。
公共静态类常量对于现有的基类静态，添加至少两个名称和与MAX_EMAIL_ADDRESS_LENGTH和DEFAULT_EMAIL_ADDRESS类似或相同的含义。查找电子邮件地址的最大长度，并将其设置为不大于此值（但为了便于测试，您可以缩小）。
其他私有成员数据。 string fromAddress;。 string toAddress;公共方法●默认和4参数构造函数。使用构造函数链接。
●新成员的Mutator和Accessor。
●覆盖基类的那些有意义的方法。考虑一下并得出自己的结论。
私有方法●私有静态验证帮助程序来过滤错误的电子邮件地址。你应该做到最低限度，但你不必比那更完整。这只是为了表明您可以执行基本过滤。最小值是方法isValidEAddr（）（或类似名称），它测试长度和至少一个'@'和一个'。'字符的存在。更进一步取决于你，但不要过度或过于严格。
推荐测试o。类电子邮件
类似于Message类。
电子邮件类的示例测试运行（与整个程序运行相同的运行完成）电子邮件派生类测试****** *****************************
来自：lili999 @ g mail.com
收件人：hloe123 @ g mail.com.com
作者：lili koi留言---------------- -----
Arf，arf，arf，arf ........ arf
来自：chloe123 @ g mail.com
收件人：lili999 @ g mail.com
作者：chloe留言------------------- -
树皮树皮
测试电子邮件访问者：
lili999 @ g mail.com
lili999 @ g mail .com
测试电子邮件变换器：
太长（按预期）
来自：lili999 @ g mail.com
收件人：hloe123 @ g mail.com.com
作者：lili koi留言---------------------
Arf，arf，arf，arf ........ arf
缺少@ char（正如预期的那样）
来自：lili999 @ g mail.com
To：hloe123 @ g mail.com.com
作者：lili koi留言---------------------
Arf，arf ，arf，arf ........ arf
缺少DOT字符（正如预期的那样）
来自：lili999 @ g mail .com
收件人：hloe123 @ g mail.com.com
作者：lili koi留言----------------- ----
Arf，arf，arf，arf ........ arf
-------------- ------------------------------------------- * /
派生类：Shweet你的第二个派生类名为Shweet。
（它就像一个Twitter推文，但因为我无法确定Tweet的细节正是我的意思在这里陈述，我们将从Twitter中解除这一点，并通过法令制定对Shweet准确的限制。）
Shweet使用已经存在于基类中的两个成员。 Shweet的消息是基类的消息，基类的作者是Shweet的作者的实际名称（不是我将在下面介绍的Shwitter ID）。不要试图将Shweet的邮件正文或作者存储为新成员，否则您将得到-20分，如上所述。
公共静态类常量对于现有的基类静态，添加三个带有名称和MAX_SHWITTER_ID_LENGTH（15），MAX_SHWEET_LENGTH（140）和DEFAULT_USER_ID的含义相同或相同。查找并使用前两个常量的实际最大长度。
虽然MAX_SHWEET_LENGTH将小于基类的MAX_MSG_LENGTH，但不要在实现中假设这一事实。 Shweet的有效消息长度必须小于这两个值。如果它不是有效的基类消息，则它不是有效的Shweet消息，如果我们稍后将MAX_SHWEET_LENGTH长度更改为5000万，则应该为真。
来自ID的附加私有成员数据字符串;公共方法●默认和3参数构造函数。当它可能有意义时，使用构造函数链接。考虑要链接到哪个构造函数。
●新成员的Mutator和Accessor。
●覆盖基类的那些有意义的方法。想一想这个并得出你自己的结论。您必须以某种方式强制执行同一消息成员的基类和派生类的长度限制。
私有方法●私有静态验证帮助程序（复数）来过滤掉错误的推文和shwitter ID。创建一个。 isValidShweet（）用于消息。另外，为Shwitter ID创建一个isValidShwitterID（）。但是，制作第三个甚至更低级别的帮助程序，使isValidShwitterID（）清晰明了。这个助手助手应该命名为stringHasOnlyAlphaOrNumOrUnderscore（），并且该名称告诉你它应该做的事情：它应该确保shwitter ID只包含字母，数字或下划线（'_'）的某种组合。这个方法的名称很好 - 不要尝试对它应用布尔逻辑，因为没有办法这样做。这个定义是你关心的。另外，我不在乎您是否认为Shwitter ID区分大小写。如果你不知道内置的C +。字符串或字符方法可以帮助您，在线查找它们。它们很容易找到。
推荐测试o。类Shweet类似于Message类。
Shweet类的示例测试运行（在整个程序运行的同一次运行中完成）Shweet派生类测试************** *********************
Shweet：Kim Kardashian @kimkardashian
Oh Deer https://www.keek.com/!PYjCdab
Shweet：Katy Perry @katyperry
这是一个动词和一个形容词。
测试Shweet访问者：
kimkardashian
测试Shweet mutators：
坏的shwitter ID（如预期的那样）
Shweet：Kim Kardashian @kimkardashian
哦鹿鹿https://www.keek.com/!PYjCdab
可接受的shwitter ID（正如预期的那样）
Shweet：Kim Kardashian @ a_good_user99
Oh Deer https://www.keek.com /！PYjCdab
--------------------------------------- ------------------ * /
选项B1 - 一堆消息完成，提交，选项A.完全添加StackNode和Stack类一个在模块中提出。接下来，以与我们在模块中派生FloatNode和FloatStack相同的方式派生MessageNode和MessageStack类，但根据需要进行调整以使MessageStack与Messages一起使用。通过将大多数方法转换为toString（）来更改大多数名为showXYZ（）的方法，以便客户端而不是方法执行输出。新方法只是格式化字符串以准备输出。
在客户端中，在完成OPTION A中的操作后，添加代码以创建MessageStack。然后将所有各种消息推送到堆栈。这意味着某些消息将是基类对象，而某些消息将是派生类对象。但是在客户端推送（和弹出）它们的代码是一样的。没有什么特别需要按顺序t。推送一种消息与另一种消息。也就是说，如果你正确地做到这一点，你只需推送（someMsg），不管消息someMsg恰好是什么样的风格，同样弹出。
最后，在一个循环中，pop（） MessageStack中的所有内容，并在pop（）时将其打印出来。超出堆栈的末尾，这样你可以确认你的代码没有在你从空堆栈弹出（）时断开。
如果工作正常，这个选项将只打印基类数据，因为toString（）方法不是虚拟的。应该是这样的。此外，使toString（）虚拟不会对此有所帮助，所以当你在堆栈中显示pop（）ped对象时仍然看不到派生数据时不要失望。
C ++代码与您的任务无关，并且在两种不同的语言和框架之间转换代码无论如何都不会产生好的java代码。
不要搜索快捷方式，而是坐下来完成任务，并将其作为一系列步骤阅读。想想你最近教过的东西，这应该不难。忽略C和C ++，专注于你的Java类，否则你将无法完成这项任务。
作业是你的任务，问题有点像作弊，所以应该学习基本知识，比如 java教程。
但我会告诉你，你不要在java中创建子类，但为每个类创建一个具有类名的自己的java文件。
对于类布局，最好列出所有类任务并考虑有多少类可用于分离任务和数据。根据作业的质量，您可以考虑使用 UML工具。这不是一段时间，但真正有助于您的架构。 ; - ）
This is my c++
#include<iostream>
using namespace std;
int c = 0,cost = 999;
int graph[4][4] = { {0, 10, 15, 20},
{10, 0, 35, 25},
{15, 35, 0, 30},
{20, 25, 30, 0}
};
void swap (int *x, int *y)
{
int temp;
temp = *x;
*x = *y;
*y = temp;
}
void copy_array(int *a, int n)
{
int i, sum = 0;
for(i = 0; i <= n; i++)
{
sum += graph[a[i % 4]][a[(i + 1) % 4]];
}
if (cost > sum)
{
cost = sum;
}
}
void permute(int *a, int i, int n)
{
int j, k;
if (i == n)
{
copy_array(a, n);
}
else
{
for (j = i; j <= n; j++)
{
swap((a + i), (a + j));
permute(a, i + 1, n);
swap((a + i), (a + j));
}
}
}
int main()
{
int i, j;
int a[] = {0, 1, 2, 3};
permute(a, 0, 3);
cout<<"minimum cost:"<<cost<<endl;
getch();
}
What I have tried:
I tried to convert it by creating sub classes within my main class but I just am learning C so bringing it to Java is really troubling me
this is the original question
Assignment 4 - Email, Shwitter and Inheritance
Select one option from below. All (both) options are worth the same number of points. The more advanced option(s) are provided for students who find the basic one too easy and want more of a challenge. Make sure you have read and understood
● both modules A and B this week, and
● module 2R - Lab Homework Requirements
before submitting this assignment.
OPTION A (Basic). Message, EMail and Shweet Understand the Classes and Problem Every message contains some content ("The British are coming. The British are coming!" and a creator, or author ("Paul Revere"). We could enhance these by adding other traits (date and/or time of creation), but let's keep things simple and say that these are the only two aspects of a basic message.
Some messages, however, have further components that define them. For example, an email consists of a normal message, plus at least two other items. a from email address and a to email address. An email is a message, but a special kind of message. So we can smell inheritance in the neighborhood. A message seems like it will make a good base class, and an email, having an is a relationship with message, is a good candidate for a derived class or extension of the base class message.
Meanwhile, a tweet consists of a normal message, plus at least one other item. a from user id. An tweet is a message, too. It has a different kind of specialization than an email has, so it is a different extension of the base class. (We are not considering a direct tweet, which would also require a to user id.)
Not only will both emails and tweets contain extra data than the base class, message, but in at least one instance we will see the same member (the content) have a different kind of restriction in the derived class than in the base class (can you guess what I'm suggesting before you read on?). Thus, even though we store the tweet content in the base class member, without the need for a new content area for the tweet, we will still have a different validation of the length of that message content. Warning. Because it makes sense to do so, we are going to name the message content message and the message class Message . So what I called content in the above paragraph will be known as (lower-case) message in what comes next. The class, itself, will be (upper-case) Message. You'll see. Just keep reading.
File Structure. I prefer one file for the entire program, so you can put all classes together with main() in one file.
The Base Class: Message Your base class is named Message . Public or Protected (your choice) Static Class Constants Define a full set of limits
and defaults
, like MAX_MSG_LENGTH and DEFAULT_AUTHOR, for both min, max lengths and default data of every member. Set the maximum message length to a large number (at least a million) and the maximum author length to a reasonable value like 40 or 65, not 5 or 200.
Private Member Data ● string message; ● string author; Public Methods ● Default and 2-parameter constructors.
● Mutator and Accessor for each member.
● a toString() method that provides a nicely formatted return String for potential screen I/O.
Private Methods ● private static validation helpers to filter client parameters. These will support your public methods.
Recommended test o. Class Message Instantiate two or more Message objects, some using the default constructor and some using the parameter-taking constructor. Mutate one or more of the members, and after that use the toString() to assist a screen output so we can see what all of your objects contain. Next, test one or more accessors. Finally, test two or more mutators, providing both legal and illegal arguments and testing the return values (thus demonstrating that the mutators do the right thing). Here is a sample run from my test (but you will have to imagine/deduce the source I used and create your own source for your testing, which will produce a different output).
Example Test Run of Message Class /* --------------------------------------------------------
Base Class Testing ***********************************
Author: Kinnard Message ---------------------
Some messages just aren't worth sending.
Author: loceff Message ---------------------
hello world
testing Message accessors:
Kinnard
hello world
testing Message mutators:
too long (as expected)
Author: Kinnard Message ---------------------
Some messages just aren't worth sending.
acceptable length (shoul. be)
Author: Kinnard Message ---------------------
LONG STRING abcde abcde abcde abcd. abcde abcde abcd. abcd. abcd. abcd. abc
d. abcde abcd. abcde abcde abcde
--------------------------------------------------------- */
The Derived Class: EMail Your first derived class is named Email. Email uses the two members already present in the base class. the Email's message is the message of the base class, and the author of the base class is the Emails's author's actual name (not the from email address which I will introduce next). Do not try to store an Email's message body or author as a new member of the derived class or you will get -20 points -- not desirable by you or me. Duplicating base class data in derived class means you do not understand what inheritance is, thus the significance of this kind of mistake.
Public Static Class Constants To the existing base class statics, add at least two with names and meanings similar or identical to MAX_EMAIL_ADDRESS_LENGTH and DEFAULT_EMAIL_ADDRESS. Look up the maximum length of an email address, and make yours no larger than that (but you can make is smaller for easier testing).
Additional Private Member Data . string fromAddress;. string toAddress; Public Methods ● Default and 4-parameter constructors. Use constructor chaining.
● Mutator and Accessor for the new members.
● Override those methods of the base class for which it makes sense to do so. Think about this and come to your own conclusions.
Private Methods ● private static validation helper to filter a bad email address. You should do the minimum, but you don't have to be more complete than that. This is just to show that you can perform basic filtering. The minimum is a method isValidEAddr() (or similarly named) which tests for both length and the existence of at least one '@' and one '.' character. Further is up to you, but don't overdo it or be too restrictive.
Recommended test o. Class Email
Similar to the Message class.
Example Test Run of Email Class (done in same run as overall program run) EMail Derived Class Testing ***********************************
From: lili999@g mail.com
To: hloe123@g mail.com.com
Author: lili koi Message ---------------------
Arf, arf, arf, arf ........ arf
From: chloe123@g mail.com
To: lili999@g mail.com
Author: chloe Message ---------------------
bark bark
testing EMail accessors:
lili999@g mail.com
lili999@g mail.com
testing Email mutators:
too long (as expected)
From: lili999@g mail.com
To: hloe123@g mail.com.com
Author: lili koi Message ---------------------
Arf, arf, arf, arf ........ arf
missing @ char (as expected)
From: lili999@g mail.com
To: hloe123@g mail.com.com
Author: lili koi Message ---------------------
Arf, arf, arf, arf ........ arf
missing DOT char (as expected)
From: lili999@g mail.com
To: hloe123@g mail.com.com
Author: lili koi Message ---------------------
Arf, arf, arf, arf ........ arf
--------------------------------------------------------- */
The Derived Class: Shweet Your second derived class is named Shweet.
(It is like a Twitter Tweet, but since I can't be certain that the details of a Tweet are exactly what I state here, we will disengage this from Twitter, and make the constraints that I impose accurate for a Shweet by decree.)
Shweet uses the two members already present in the base class. The Shweet's message is the message of the base class, and the author of the base class is the Shweet's author's actual name (not the Shwitter ID which I will introduce next). Do not try to store a Shweet's message body or author as new members or you will get -20 points, as mentioned above.
Public Static Class Constants To the existing base class statics, add three with a names and meaning similar or identical to MAX_SHWITTER_ID_LENGTH (15), MAX_SHWEET_LENGTH (140) and DEFAULT_USER_ID. Look up and use the actual maximum lengths of the first two constants.
While the MAX_SHWEET_LENGTH is going to be smaller than the base class's MAX_MSG_LENGTH, do not assume this fact in your implementation. A valid message length for a Shweet has to be smaller than both of these values. If it's not a valid base class message, it isn't a valid Shweet message, and this should be true if we later change the MAX_SHWEET_LENGTH length to be 50 million.
Additional Private Member Data string fromID; Public Methods ● Default and 3-parameter constructors. When it is possible and meaningful, use constructor chaining. Think about which constructor to chain to.
● Mutator and Accessor for the new member.
● Override those methods of the base class for which it makes sense to do so. Think about this and come to your own conclusions. You have to somehow enforce the length limits of both the base class and the derived class for the same message member.
Private Methods ● private static validation helpers (plural) to filter out bad tweets and shwitter IDs. Create a. isValidShweet() for the message. Also, create an isValidShwitterID() for the Shwitter ID. But also, make a third, even lower-level, helper that would make isValidShwitterID() clear and short. This helper-helper should be named something like stringHasOnlyAlphaOrNumOrUnderscore() and that name tells you the kind of thing it should do: it should make sure the shwitter ID contains only some combination of letters, numbers or an underscore ('_'). The name of this method is fine - don't try to apply boolean logic to it as there is no way to do so. The definition is what you care about. Also, I don't care whether you decide that the Shwitter ID be case sensitive. If you don't know the built-in C+. string or char methods that can help you here, look them up online. They are very easy to find.
Recommended test o. Class Shweet Similar to the Message class.
Example Test Run of Shweet Class (done in same run as overall program run) Shweet Derived Class Testing ***********************************
Shweet: Kim Kardashian @kimkardashian
Oh Deer https://www.keek.com/!PYjCdab
Shweet: Katy Perry @katyperry
It's a verb and an adjective.
testing Shweet accessors:
kimkardashian
testing Shweet mutators:
bad shwitter ID (as expected)
Shweet: Kim Kardashian @kimkardashian
Oh Deer https://www.keek.com/!PYjCdab
acceptable shwitter ID (as expected)
Shweet: Kim Kardashian @a_good_user99
Oh Deer https://www.keek.com/!PYjCdab
--------------------------------------------------------- */
OPTION B1 - A Stack of Messages Complete, for submission, OPTION A. Add StackNode and Stack classes, exactly as presented in the Modules. Next, derive MessageNode and MessageStack classes in the same manner as we derived FloatNode and FloatStack in the modules, but making adjustments, as needed, to have the MessageStack work with Messages. Change most methods named showXYZ() by converting them to toString() so that the client, not the methods, does the output. The new methods merely format the strings in preparation for output.
In your client, after you have done the things from OPTION A, add code to create a MessageStack. Then push() all the various Messages onto the stack. This means that some messages will be base class objects and some will be derived class objects. But the code to push (and pop) them in the client is the same. Nothing special need be done in order t. push one kind of Message vs. another kind. That is, if you are doing this right, you just push(someMsg) regardless of what flavor of Message someMsg happens to be, and likewise with the popping.
Finally, in a loop, pop() everything off the MessageStack and print it out as you pop(). Go beyond the end of the Stack so you can confirm that your code does not break when you pop() things off an empty Stack.
If working correctly, this option will print only the base class data, because the toString() method is not virtual. That's how it should be. Furthermore, making toString() virtual is not going to help this, so don't be disappointed if you still do not see derived data when you display the pop()ped objects as they come off the stack.
That C++ code has nothing to do with your assignment, and converting code between two dissimilar languages and frameworks isn't going to product good java code anyway.
Instead of searching for shortcuts, sit down with the assignment, and read it as a series of steps. Think about what you have been taught recently, and it shouldn't be difficult. Ignore C and C++, and concentrate on your Java classes or you will fail this task.
The homework is your task and asking is a bit like cheating and so should learn the basics like in that java tutorial.
But I will tell you that you dont create subclasses in java, but create for each class a own java file with the name of the class.
For the class layout it is best to make a list of all task and think how many classes are useful to separate taskes and data. Depending on the quality of your homework you may consider some UML tool. This isnt a waiste of time, but really helps your architecture. ;-)
这篇关于有人可以帮助我将我的C ++代码转换为java。我非常困惑，我完全错了。的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
